{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ML_in_Finance-Deep-Factor-Models\n",
    "# Author: Matthew Dixon\n",
    "# Version: 1.0 (24.7.2019)\n",
    "# License: MIT\n",
    "# Email: matthew.dixon@iit.edu\n",
    "# Notes: tested on Mac OS X with Python 3.6.9 and the following packages:\n",
    "# numpy=1.18.1, keras=2.3.1, tensorflow=2.0.0, matplotlib=3.1.3, statsmodels=0.10.1, scikit-learn=0.22.1\n",
    "# Citation: Please cite the following reference if this notebook is used for research purposes:\n",
    "# Dixon M.F., I. Halperin and P. Bilokon, Machine Learning in Finance: From Theory to Practice, Springer Graduate textbook Series, 2020. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overview"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The purpose of this notebook is to demonstrate the application of deep learning to fundamental factor modeling. The outputs are monthly excess returns, the inputs are fundamental factor loadings (BARRA style). The data provided has already been normalized. \n",
    "\n",
    "The notebook describes the data loading, training using walk-forward optimization, performance evaluation and comparison with ordinary least squares (OLS) regression. The toy dataset consists of 6 fundamental factors for 218 stocks over a 100 month period starting in February 2008. \n",
    "\n",
    "See the description of the smaller dataset described in Section 6.2 of Chpt 5. See Table 5.4 for a description of the factors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout\n",
    "from keras.regularizers import l1\n",
    "from keras.wrappers.scikit_learn import KerasRegressor\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from keras.callbacks import EarlyStopping\n",
    "import timeit\n",
    "import statsmodels.api as sm\n",
    "from dateutil.relativedelta import relativedelta\n",
    "\n",
    "%matplotlib inline "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define a deep neural network (with $L-1$ hidden layers) model in Keras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define functions for the creation, training, and optional parameter tuning of the model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def NN(n_inputs, n_units=10, dropout=0.1, l1_reg=0.001, activation='relu', L=2):\n",
    "    # L>0 is the number of hidden layers\n",
    "    \n",
    "    model = Sequential()\n",
    "    model.add(Dense(units=n_units, input_dim=n_inputs, kernel_regularizer=l1(l1_reg), kernel_initializer='normal', activation=activation))\n",
    "    model.add(Dropout(dropout))\n",
    "    for i in range (0, L-1):\n",
    "        model.add(Dense(units=n_units, kernel_regularizer=l1(l1_reg), kernel_initializer='normal', activation=activation))\n",
    "        model.add(Dropout(dropout))\n",
    "    model.add(Dense(1, kernel_initializer='normal')) \n",
    "    model.compile(loss='mean_squared_error', optimizer='adam', metrics=['mae'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "es = EarlyStopping(monitor='loss', mode='min', verbose=1, patience=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function selects the best-performing combination of parameter values in `param_grid` cross-validated over `cv` folds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parameter_tuning(X, y, cv=3, n_epochs=100, n_batch=10, seed=7):\n",
    "    param_grid = dict(n_inputs=[X.shape[1]], n_units=[10, 20, 50], \n",
    "                      l1_reg = [0, 0.0001, 0.001], activation=['relu','tanh']) \n",
    "    estimator = KerasRegressor(build_fn=NN, epochs=n_epochs, batch_size=n_batch, verbose=0)   \n",
    "    grid = GridSearchCV(estimator=estimator, param_grid=param_grid, \n",
    "                        cv=cv)\n",
    "    grid_result = grid.fit(X, y, callbacks=[es])\n",
    "  \n",
    "    print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))\n",
    "    means = grid_result.cv_results_['mean_test_score']\n",
    "    stds = grid_result.cv_results_['std_test_score']\n",
    "    params = grid_result.cv_results_['params']\n",
    "    for mean, stdev, param in zip(means, stds, params):\n",
    "        print(\"%f (%f) with: %r\" % (mean, stdev, param))\n",
    "    return grid_result.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def training(X, Y, training_dates, L, tune=False):\n",
    " \n",
    "    n_epochs = 100 # maximum number of epochs (to be used with early stopping)\n",
    "    n_batch = 10 # mini-batch size\n",
    "    drop_out = 0.0 # level of dropout (set between 0 and 1)\n",
    "    n_units = 10   \n",
    "    l1_reg = 0.001 # L_1 regularization parameter\n",
    "    activation = 'tanh'\n",
    "\n",
    "    # Create the dictionaries to hold the results\n",
    "    models = {}\n",
    "    models['linear'] = []\n",
    "    models['NN'] = []\n",
    "\n",
    "    xs = {}\n",
    "    xs['train'] = []\n",
    "    xs['test'] = []\n",
    "    \n",
    "    ys = {}\n",
    "    ys['train'] = []\n",
    "    ys['test'] = []\n",
    "    \n",
    "    betas = {}\n",
    "    betas['NN'] = []\n",
    "    betas['linear'] = []\n",
    "\n",
    "    i = 0\n",
    "    for date in training_dates:\n",
    "        start_time = timeit.default_timer()  \n",
    "        print(i, date)\n",
    "        \n",
    "        # The following month's date (for the test set)\n",
    "        date_next = pd.Timestamp(np.datetime64(date)).to_pydatetime() + relativedelta(months=+1)\n",
    "        date_next = date_next.strftime('%Y-%m-%d')\n",
    "\n",
    "        # Get the indices of the training and testing points\n",
    "        train_index = X[X['date'] == date].index\n",
    "        test_index  = X[X['date'] == date_next].index\n",
    "        \n",
    "        # Skip the model if either the train or test sets would be empty\n",
    "        if len(train_index) == 0 or len(test_index) == 0:\n",
    "            continue\n",
    "\n",
    "        # Make the train and test sets\n",
    "        x_train = X.loc[train_index]\n",
    "        x_train = x_train.drop(\"date\", axis=1)\n",
    "        y_train = Y.loc[train_index]\n",
    "        y_train= y_train.drop(\"date\", axis=1)\n",
    "        x_test = X.loc[test_index]\n",
    "        x_test = x_test.drop(\"date\", axis=1)\n",
    "        y_test = Y.loc[test_index]\n",
    "        y_test = y_test.drop(\"date\", axis=1)\n",
    "        \n",
    "        n_inputs = x_train.shape[1]\n",
    "        if n_inputs == 0:\n",
    "            continue\n",
    "       \n",
    "        if tune: # Only perform parameter tuning once\n",
    "            print(\"Parameter tuning with X-validation...\")\n",
    "            best_params = parameter_tuning(x_train, y_train, 3)\n",
    "            n_units = best_params['n_units']\n",
    "            l1_reg = best_params['l1_reg']\n",
    "            activation = best_params['activation']\n",
    "            tune = False\n",
    "        \n",
    "        # Create and fit the NN for the current training date\n",
    "        model = NN(n_units=n_units, n_inputs=n_inputs, dropout=drop_out, l1_reg=l1_reg, activation=activation, L=L)\n",
    "        model.fit(x_train.values, y_train.values, epochs=n_epochs, batch_size=n_batch, verbose=0, callbacks=[es])   \n",
    "        beta = sensitivities(model, x_train.values, L, activation)   \n",
    "        \n",
    "        # Save the results\n",
    "        models['NN'].append(model)\n",
    "        betas['NN'].append(beta)\n",
    "        \n",
    "        # Fit the OLS regression model for the current date\n",
    "        x = sm.add_constant(x_train)\n",
    "        model = sm.OLS(y_train, x).fit()   \n",
    "        \n",
    "        # Save the results\n",
    "        betas['linear'].append(model.params)\n",
    "        models['linear'].append(model)\n",
    "        \n",
    "        # Save the corresponding inputs and outputs for each model \n",
    "        xs['train'].append(x_train)\n",
    "        xs['test'].append(x_test)\n",
    "        ys['train'].append(y_train)\n",
    "        ys['test'].append(y_test)\n",
    "\n",
    "        elapsed = timeit.default_timer() - start_time\n",
    "        print(\"Elapsed time: \" + str(elapsed) + \" (s)\")\n",
    "        i += 1\n",
    "        \n",
    "    return models, betas, xs, ys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function allows us to compute the feature sensitivities in the deep network. It assumes that the activation function is either $tanh$ or $relu$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sensitivities(lm, X, L, activation='tanh'):\n",
    "    W = lm.get_weights()\n",
    "    M = np.shape(X)[0]\n",
    "    p = np.shape(X)[1]\n",
    "    beta = np.zeros((M, p+1))\n",
    "    B_0 = W[1]\n",
    "    for i in range (0, L):\n",
    "        if activation == 'tanh':  \n",
    "            B_0 = (np.dot(np.transpose(W[2*(i+1)]), np.tanh(B_0)) + W[2*(i+1)+1])\n",
    "        elif activation == 'relu':\n",
    "            B_0 = (np.dot(np.transpose(W[2*(i+1)]), np.maximum(B_0, 0)) + W[2*(i+1)+1])\n",
    "    beta[:, 0] = B_0 # intercept \\beta_0 = F_{W,b}(0)\n",
    "    for i in range(M):\n",
    "        I1 = np.dot(np.transpose(W[0]), np.transpose(X[i,])) + W[1]\n",
    "        if activation == 'tanh':\n",
    "            Z = np.tanh(I1)  \n",
    "            D = np.diag(1 - Z**2)\n",
    "        elif activation == 'relu':\n",
    "            Z = np.maximum(I1, 0)\n",
    "            D = np.diag(np.sign(Z)) \n",
    "        \n",
    "        for j in range(p):\n",
    "            J = np.dot(D, W[0][j])       \n",
    "            for a in range (1, L):\n",
    "                I = np.dot(np.transpose(W[2*a]), Z) + W[2*a+1] \n",
    "                if activation == 'tanh':  \n",
    "                    Z = np.tanh(I)\n",
    "                    D = np.diag(1 - Z**2)\n",
    "                elif activation == 'relu':    \n",
    "                    Z = np.maximum(I,0)\n",
    "                    D = np.diag(np.sign(Z)) \n",
    "                J = np.dot(np.dot(D, np.transpose(W[2*a])), J)\n",
    "            beta[i, j+1]=np.dot(np.transpose(W[2*L]), J)\n",
    "    return beta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = pd.read_csv('../data/X_small.csv') # Factor exposures\n",
    "Y = pd.read_csv('../data/Y_small.csv') # Asset returns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training of models \n",
    "A new cross-sectional neural network model is fitted in each period. To evaluate the performance of strategies, we need to train a model for each time step over a historical period. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2008-02-01\n",
      "Parameter tuning with X-validation...\n",
      "Epoch 00024: early stopping\n",
      "Epoch 00024: early stopping\n",
      "Epoch 00025: early stopping\n",
      "Epoch 00019: early stopping\n",
      "Epoch 00025: early stopping\n",
      "Epoch 00014: early stopping\n",
      "Epoch 00005: early stopping\n",
      "Epoch 00021: early stopping\n",
      "Epoch 00019: early stopping\n",
      "Epoch 00015: early stopping\n",
      "Epoch 00019: early stopping\n",
      "Epoch 00012: early stopping\n",
      "Epoch 00019: early stopping\n",
      "Epoch 00025: early stopping\n",
      "Epoch 00014: early stopping\n",
      "Epoch 00025: early stopping\n",
      "Epoch 00022: early stopping\n",
      "Epoch 00023: early stopping\n",
      "Epoch 00015: early stopping\n",
      "Epoch 00013: early stopping\n",
      "Epoch 00012: early stopping\n",
      "Epoch 00024: early stopping\n",
      "Epoch 00015: early stopping\n",
      "Epoch 00020: early stopping\n",
      "Epoch 00027: early stopping\n",
      "Epoch 00026: early stopping\n",
      "Epoch 00020: early stopping\n",
      "Epoch 00025: early stopping\n",
      "Epoch 00021: early stopping\n",
      "Epoch 00019: early stopping\n",
      "Epoch 00009: early stopping\n",
      "Epoch 00019: early stopping\n",
      "Epoch 00019: early stopping\n",
      "Epoch 00013: early stopping\n",
      "Epoch 00007: early stopping\n",
      "Epoch 00009: early stopping\n",
      "Epoch 00028: early stopping\n",
      "Epoch 00025: early stopping\n",
      "Epoch 00029: early stopping\n",
      "Epoch 00026: early stopping\n",
      "Epoch 00021: early stopping\n",
      "Epoch 00021: early stopping\n",
      "Epoch 00040: early stopping\n",
      "Epoch 00035: early stopping\n",
      "Epoch 00032: early stopping\n",
      "Epoch 00019: early stopping\n",
      "Epoch 00016: early stopping\n",
      "Epoch 00020: early stopping\n",
      "Epoch 00027: early stopping\n",
      "Epoch 00019: early stopping\n",
      "Epoch 00016: early stopping\n",
      "Epoch 00020: early stopping\n",
      "Epoch 00022: early stopping\n",
      "Epoch 00020: early stopping\n",
      "Epoch 00020: early stopping\n",
      "Best: -0.007279 using {'activation': 'relu', 'l1_reg': 0.0001, 'n_inputs': 6, 'n_units': 10}\n",
      "-0.008835 (0.000649) with: {'activation': 'relu', 'l1_reg': 0, 'n_inputs': 6, 'n_units': 10}\n",
      "-0.015021 (0.009258) with: {'activation': 'relu', 'l1_reg': 0, 'n_inputs': 6, 'n_units': 20}\n",
      "-0.011719 (0.003230) with: {'activation': 'relu', 'l1_reg': 0, 'n_inputs': 6, 'n_units': 50}\n",
      "-0.007279 (0.000944) with: {'activation': 'relu', 'l1_reg': 0.0001, 'n_inputs': 6, 'n_units': 10}\n",
      "-0.007558 (0.001022) with: {'activation': 'relu', 'l1_reg': 0.0001, 'n_inputs': 6, 'n_units': 20}\n",
      "-0.008031 (0.001275) with: {'activation': 'relu', 'l1_reg': 0.0001, 'n_inputs': 6, 'n_units': 50}\n",
      "-0.007280 (0.000895) with: {'activation': 'relu', 'l1_reg': 0.001, 'n_inputs': 6, 'n_units': 10}\n",
      "-0.007314 (0.000903) with: {'activation': 'relu', 'l1_reg': 0.001, 'n_inputs': 6, 'n_units': 20}\n",
      "-0.007781 (0.000996) with: {'activation': 'relu', 'l1_reg': 0.001, 'n_inputs': 6, 'n_units': 50}\n",
      "-0.007768 (0.001649) with: {'activation': 'tanh', 'l1_reg': 0, 'n_inputs': 6, 'n_units': 10}\n",
      "-0.007982 (0.001714) with: {'activation': 'tanh', 'l1_reg': 0, 'n_inputs': 6, 'n_units': 20}\n",
      "-0.007867 (0.001668) with: {'activation': 'tanh', 'l1_reg': 0, 'n_inputs': 6, 'n_units': 50}\n",
      "-0.007907 (0.001387) with: {'activation': 'tanh', 'l1_reg': 0.0001, 'n_inputs': 6, 'n_units': 10}\n",
      "-0.008020 (0.001282) with: {'activation': 'tanh', 'l1_reg': 0.0001, 'n_inputs': 6, 'n_units': 20}\n",
      "-0.008271 (0.001545) with: {'activation': 'tanh', 'l1_reg': 0.0001, 'n_inputs': 6, 'n_units': 50}\n",
      "-0.007319 (0.000930) with: {'activation': 'tanh', 'l1_reg': 0.001, 'n_inputs': 6, 'n_units': 10}\n",
      "-0.007339 (0.000867) with: {'activation': 'tanh', 'l1_reg': 0.001, 'n_inputs': 6, 'n_units': 20}\n",
      "-0.007539 (0.000907) with: {'activation': 'tanh', 'l1_reg': 0.001, 'n_inputs': 6, 'n_units': 50}\n",
      "{'activation': 'relu', 'l1_reg': 0.0001, 'n_inputs': 6, 'n_units': 10}\n",
      "Elapsed time:334.29772021700046 (s)\n",
      "1 2008-03-01\n",
      "Elapsed time:3.204688730998896 (s)\n",
      "2 2008-04-01\n",
      "Elapsed time:2.5196995599981165 (s)\n",
      "3 2008-05-01\n",
      "Elapsed time:2.6039689339959295 (s)\n",
      "4 2008-06-01\n",
      "Elapsed time:2.3879191349988105 (s)\n",
      "5 2008-07-01\n",
      "Elapsed time:2.541321626995341 (s)\n",
      "6 2008-08-01\n",
      "Elapsed time:2.311797274000128 (s)\n",
      "7 2008-09-01\n",
      "Elapsed time:2.4358518189983442 (s)\n",
      "8 2008-10-01\n",
      "Elapsed time:2.5007678880065214 (s)\n",
      "9 2008-11-01\n",
      "Elapsed time:2.4259906470106216 (s)\n",
      "10 2008-12-01\n",
      "Elapsed time:5.874883789991145 (s)\n",
      "11 2009-01-01\n",
      "Elapsed time:2.549434811997344 (s)\n",
      "12 2009-02-01\n",
      "Elapsed time:2.513443019997794 (s)\n",
      "13 2009-03-01\n",
      "Elapsed time:2.644825777009828 (s)\n",
      "14 2009-04-01\n",
      "Elapsed time:2.9503703369991854 (s)\n",
      "15 2009-05-01\n",
      "Elapsed time:3.103468443005113 (s)\n",
      "16 2009-06-01\n",
      "Elapsed time:3.5158980609994614 (s)\n",
      "17 2009-07-01\n",
      "Elapsed time:3.0404791829932947 (s)\n",
      "18 2009-08-01\n",
      "Elapsed time:3.0557063730084337 (s)\n",
      "19 2009-09-01\n",
      "Elapsed time:2.951567679992877 (s)\n",
      "20 2009-10-01\n",
      "Elapsed time:2.8056144599977415 (s)\n",
      "21 2009-11-01\n",
      "Elapsed time:2.605560141004389 (s)\n",
      "22 2009-12-01\n",
      "Elapsed time:3.0715104679984506 (s)\n",
      "23 2010-01-01\n",
      "Elapsed time:3.260850902996026 (s)\n",
      "24 2010-02-01\n",
      "Elapsed time:3.154943839996122 (s)\n",
      "25 2010-03-01\n",
      "Elapsed time:2.654853539992473 (s)\n",
      "26 2010-04-01\n",
      "Elapsed time:2.8079204520036 (s)\n",
      "27 2010-05-01\n",
      "Elapsed time:2.9655642559955595 (s)\n",
      "28 2010-06-01\n",
      "Elapsed time:12.870572165003978 (s)\n",
      "29 2010-07-01\n",
      "Elapsed time:11.544557499990333 (s)\n",
      "30 2010-08-01\n",
      "Elapsed time:3.2253230759961298 (s)\n",
      "31 2010-09-01\n",
      "Elapsed time:2.779214566995506 (s)\n",
      "32 2010-10-01\n",
      "Elapsed time:2.5233199689973844 (s)\n",
      "33 2010-11-01\n",
      "Elapsed time:2.796262122996268 (s)\n",
      "34 2010-12-01\n",
      "Elapsed time:2.599818836999475 (s)\n",
      "35 2011-01-01\n",
      "Elapsed time:2.5991340009932173 (s)\n",
      "36 2011-02-01\n",
      "Elapsed time:2.702329842999461 (s)\n",
      "37 2011-03-01\n",
      "Elapsed time:2.363431378005771 (s)\n",
      "38 2011-04-01\n",
      "Elapsed time:2.3024537730088923 (s)\n",
      "39 2011-05-01\n",
      "Elapsed time:2.3850999010028318 (s)\n",
      "40 2011-06-01\n",
      "Elapsed time:2.2878667039913125 (s)\n",
      "41 2011-07-01\n",
      "Elapsed time:2.567189043998951 (s)\n",
      "42 2011-08-01\n",
      "Elapsed time:2.3389144749962725 (s)\n",
      "43 2011-09-01\n",
      "Elapsed time:2.3225109319901094 (s)\n",
      "44 2011-10-01\n",
      "Elapsed time:2.3134547259978717 (s)\n",
      "45 2011-11-01\n"
     ]
    }
   ],
   "source": [
    "training_periods = 100\n",
    "L = 2 # Number of hidden and output layers\n",
    "dates = np.unique(X['date'])[0:training_periods] \n",
    "models, betas, xs, ys = training(X, Y, dates, L, False) # Set last argument to True to perform cross-validation for parameter tuning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Performance evaluation\n",
    "\n",
    "We note, for this small dataset, that the difference in the MSEs between OLS and neural networks is marginal, however, the L_inf norms are substantially different, indicating the superior ability of the neural network to capture outliers. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate MSE of OLS out-of-sample\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE: 0.017511483871247034\n"
     ]
    }
   ],
   "source": [
    "MSE = 0\n",
    "y_hat_linear = []\n",
    "MSE_array_linear = np.array([0]*training_periods, dtype='float64')\n",
    "for i in range(training_periods):\n",
    "    x = sm.add_constant(xs['test'][i].values)\n",
    "    y_hat_linear.append(models['linear'][i].predict(x))\n",
    "    MSE_test_linear = mean_squared_error(y_hat_linear[-1], ys['test'][i].values)\n",
    "    MSE_array_linear[i] = MSE_test_linear\n",
    "    MSE += MSE_test_linear\n",
    "print(\"MSE: \" + str(MSE / training_periods))    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate MSE of OLS in-sample\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE: 0.004573922402548681\n"
     ]
    }
   ],
   "source": [
    "MSE = 0\n",
    "MSE_array_linear_in = np.zeros(training_periods).astype('float64')\n",
    "y_hat_linear_is = []\n",
    "for i in range(training_periods):\n",
    "    x = sm.add_constant(xs['train'][i].values)\n",
    "    y_hat_linear_is.append(models['linear'][i].predict(x))\n",
    "    MSE_test_linear = mean_squared_error(y_hat_linear_is[-1], ys['train'][i].values)\n",
    "    MSE_array_linear_in[i] = MSE_test_linear\n",
    "    MSE += MSE_test_linear\n",
    "print(\"MSE: \" + str(MSE / training_periods))    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate $L_{\\infty}$ norm of OLS out-of-sample\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inf-norm: 0.5148467207968435\n"
     ]
    }
   ],
   "source": [
    "inf_norm = 0\n",
    "y_hat_linear = []\n",
    "inf_norm_linear_out = np.array([0]*training_periods, dtype='float64')\n",
    "for i in range(training_periods):\n",
    "    x = sm.add_constant(xs['test'][i].values)\n",
    "    y_hat_linear.append(models['linear'][i].predict(x))\n",
    "    inf_norm_linear = np.max(np.abs(y_hat_linear[-1] - ys['test'][i].values))\n",
    "    inf_norm_linear_out[i] = inf_norm_linear\n",
    "    inf_norm += inf_norm_linear\n",
    "print(\"inf-norm: \" + str(inf_norm / training_periods))   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate $L_{\\infty}$ norm of OLS in-sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inf-norm: 0.4225199869563092\n"
     ]
    }
   ],
   "source": [
    "inf_norm = 0\n",
    "y_hat_linear = []\n",
    "inf_norm_linear_in = np.array([0]*training_periods, dtype='float64')\n",
    "for i in range(training_periods):\n",
    "    x = sm.add_constant(xs['train'][i].values)\n",
    "    y_hat_linear.append(models['linear'][i].predict(x))\n",
    "    inf_norm_linear = np.max(np.abs(y_hat_linear[-1] - ys['train'][i].values))\n",
    "    inf_norm_linear_in[i] = inf_norm_linear\n",
    "    inf_norm += inf_norm_linear\n",
    "print(\"inf-norm: \" + str(inf_norm/training_periods)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate MSE of NN out-of-sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE: 0.016814848608209615\n"
     ]
    }
   ],
   "source": [
    "MSE = 0\n",
    "MSE_array_NN = np.array([0]*training_periods, dtype='float64')\n",
    "y_hat_NN = []\n",
    "for i in range(training_periods):\n",
    "    y_hat_NN.append(models['NN'][i].predict(xs['test'][i].values))\n",
    "    MSE_test_NN = mean_squared_error(y_hat_NN[-1], ys['test'][i].values)\n",
    "    MSE_array_NN[i] = MSE_test_NN\n",
    "    MSE += MSE_test_NN\n",
    "print(\"MSE: \" + str(MSE / training_periods))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate MSE of NN in-sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE: 0.005145836431011453\n"
     ]
    }
   ],
   "source": [
    "MSE = 0\n",
    "MSE_array_NN_in = np.array([0]*training_periods, dtype='float64')\n",
    "y_hat_NN_is = []\n",
    "for i in range(training_periods):\n",
    "    y_hat_NN_is.append(models['NN'][i].predict(xs['train'][i].values))\n",
    "    MSE_test_NN = mean_squared_error(y_hat_NN_is[-1], ys['train'][i].values)\n",
    "    MSE_array_NN_in[i] = MSE_test_NN\n",
    "    MSE += MSE_test_NN\n",
    "print(\"MSE: \" + str(MSE / training_periods)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate $L_{\\infty}$ norm of NN out-of-sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inf-norm: 0.38414703878522516\n"
     ]
    }
   ],
   "source": [
    "inf_norm = 0\n",
    "inf_norm_test_NN = np.array([0]*training_periods, dtype='float64')\n",
    "y_hat_NN = []\n",
    "for i in range(training_periods):\n",
    "    y_hat_NN.append(models['NN'][i].predict(xs['test'][i].values))\n",
    "    inf_norm_NN = np.max(np.abs(y_hat_NN[-1] - ys['test'][i].values))\n",
    "    inf_norm_test_NN[i] = inf_norm_NN\n",
    "    inf_norm += inf_norm_NN\n",
    "print(\"inf-norm: \" + str(inf_norm/training_periods))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate $L_{\\infty}$ of NN in-sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inf-norm: 0.33293916186696443\n"
     ]
    }
   ],
   "source": [
    "inf_norm = 0\n",
    "inf_norm_train_NN = np.array([0]*training_periods, dtype='float64')\n",
    "y_hat_NN_is = []\n",
    "for i in range(training_periods):\n",
    "    y_hat_NN_is.append(models['NN'][i].predict(xs['train'][i].values))\n",
    "    inf_norm_NN = np.max(np.abs(y_hat_NN_is[-1]- ys['train'][i].values))\n",
    "    inf_norm_train_NN[i] = inf_norm_NN\n",
    "    inf_norm += inf_norm_NN\n",
    "print(\"inf-norm: \" + str(inf_norm/training_periods))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $L_2$ norms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(MSE_array_NN_in, color='red', label='NN')\n",
    "plt.plot(MSE_array_linear_in, color='blue', label='OLS')\n",
    "plt.ylabel('MSE (in-sample)')\n",
    "plt.xlabel('t')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(MSE_array_NN, color='red', label='NN')\n",
    "plt.plot(MSE_array_linear, color='blue', label='OLS')\n",
    "plt.ylabel('MSE (out-of-sample)')\n",
    "plt.xlabel('t')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $L_{\\infty}$ norms "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEGCAYAAABhMDI9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOy9d5ikVZn3/zlVnaqqc5jpmemeyAzDDAMCQ3AFBVEXV1bFVVdMKyyyAcMqa1xfQPfFd2URw64uCiq6KiqKOhh+BgzEQQaJEwiTm0k9nStXV53fH/fz1PNU7Kruqu7q5nyuq6/qyqeqnud8z/e+z7mP0lpjMBgMBoONZ64bYDAYDIbawgiDwWAwGDIwwmAwGAyGDIwwGAwGgyEDIwwGg8FgyKBurhswU7q7u/XKlSvnuhkGg8Ewr3jkkUeOa6178t0374Vh5cqVbNu2ba6bYTAYDPMKpdT+QveZUJLBYDAYMjDCYDAYDIYMjDAYDAaDIYN5n2MwGAyGSpBIJBgYGCAajc51UypKU1MTfX191NfXl/wcIwwGg8EADAwM0NLSwsqVK1FKzXVzKoLWmqGhIQYGBli1alXJzzOhJIPBYACi0ShdXV0LRhQAlFJ0dXWV7YKMMBgMBoPFQhIFm+l8JiMM84BoFG69FRKJuW6JwWB4IWCEYR5w993w7nfDbbfNdUsMBkM1UUpx9dVXp6/feOONXHfddQBcd911+P1+jh07lr6/ubm5Ku0wwjAPCAbl8nOfA7OvksGwcGlsbOTOO+/k+PHjee/v7u7ms5/9bNXbYYRhHhCJyOXOnfCrX81tWwwGQ/Woq6vjyiuv5HOf+1ze+y+//HK+//3vMzw8XN12VPXVDRUhHJbLlha46Sa46KK5bY/BsOD5l3+Bxx6r7Gu+6EXw+c9P+bCrrrqKU045hQ9/+MM59zU3N3P55ZfzhS98gU9+8pOVbZ8L4xjmAbZjuOoq+M1v4Kmn5rY9BoOherS2tvLOd76TL37xi3nvf9/73sc3v/lNxsfHq9aGWXMMSqmvAxcDx7TWJ+e5/23AR6yrQeCftNaPz1b7ahlbGD7wAfjiFyXX8LWvzW2bDIYFTQkj+2ryL//yL5x++ulcdtllOfe1t7fz1re+lS9/+ctVe//ZdAy3AcWCIHuBl2mtTwH+HfjqbDRqPhAOQ10dLFoEf/d38O1vg2tigsFgWGB0dnby5je/ma8VGAF+8IMf5Ctf+QqTk5NVef9ZEwat9T1AwYyJ1voBrfWIdXUr0DcrDZsHRCLg88n/b30rxOPw8MNz2yaDwVBdrr766qKzky655BJisVhV3rtWk89/D/yy0J1KqSuBKwGWL18+W22aMyIR8Pvl/5YWuazS8WAwGOaQoD03HVi8eDFhe+YJpNcz2Nx0003cdNNNVWlHzSWflVIXIMLwkUKP0Vp/VWu9WWu9uacn7850C4pw2HEMjY1yaYTBYDBUi5pyDEqpU4BbgVdrrYfmuj21gtsxNDTIZTw+d+0xGAwLm5pxDEqp5cCdwDu01s/MdXtqCXeOwTgGg8FQbWZzuurtwPlAt1JqALgWqAfQWt8MXAN0AV+2qgFOaq03z1b7ahkTSjIYDLPJrAmD1vrSKe6/Arhilpozr4hEoLVV/jehJIPBUG1qJpRkKIwJJRkMhtnECMM8wB1Ksh2DEQaDYeExMDDA6173OtauXcuaNWt4//vfTzwe5w9/+AMXX3xxzuN/9rOfcdppp3HqqaeyYcMGvvKVr1SkHUYY5gHuWUlKQX29CSUZDAsNrTVveMMbeP3rX8+zzz7LM888QzAY5N/+7d/yPj6RSHDllVdy11138fjjj/Poo49y/vnnV6QtNTVd1ZAft2MACScZx2AwLCx+97vf0dTUlK6P5PV6+dznPseqVau44IILch4/MTHB5OQkXV1dgOzlcOKJJ1akLUYY5gHuHAOIMBjHYDBUj7mour19+3bOOOOMjNtaW1tZvnw5zz33XM7jOzs7ee1rX8uKFSu48MILufjii7n00kvxeGYeCDKhpBpH68xQEkiewTgGg2FhobXGmqpf0u0At956K3fffTdnnXUWN954I5dffnlF2mIcQ40TjcqlCSUZDLPHXFTd3rhxIz/60Y8ybhsfH+fgwYOsWbOm4PM2bdrEpk2beMc73sGqVau4rQKbwxvHUOPYezGYUJLBsLC58MILCYfDfOtb3wIgmUxy9dVX8653vQu/O2RgEQwG+cMf/pC+/thjj7FixYqKtMUIQ41jC4MJJRkMCxulFD/+8Y+54447WLt2LevWraOpqYlPf/rTANx999309fWl/x599FFuuOEGTjzxRF70ohdx7bXXVsQtgAkl1Tx21V0TSjIYFj79/f3cddddObeff/75ROxRoovzzjuvKu0wjqHGMaEkg8Ew2xhhqHFMKMlgMMw2RhhqnHQoKTqSvs2EkgyG6qC1nusmVJzpfCYjDDVOOpT0hlfDjh2ACSUZDNWgqamJoaGhBSUOWmuGhoZoamoq63km+VzjpENJhOCJJ2DDBhNKMhiqQF9fHwMDAwwODs51UypKU1MTfX19ZT3HCEONkw4lEYHduwETSjIYqkF9fT2rVq2a62bUBCaUVOM4jiEMe/YAJpRkMBiqixGGGiedY3A5BhNKMhgM1cQIQ42TEUpyOQYjDAaDoVoYYahxIhFQStNIDAYGIBYzoSSDwVBVjDDUOOEw+OoSKJAa3Hv3pkNJC2hWncFgqCGMMNQ4kYgIQ5o9e2hslH8TifzPMRgMhplghKHGiUTA7xaG3bvTwmDCSQaDoRoYYahxJJQUh+ZmCARgzx4aGuQ+k4A2GAzVwAhDjROJgM8Tg6YmWL06wzEYYTAYDNXACEONE4mA3xuTOaqrV2fkGEwoyWAwVINZEwal1NeVUseUUk8VuF8ppb6olHpOKfWEUur02WpbLRMOg09ZwrBmjYSS6mU6knEMBoOhGsymY7gNuKjI/a8G1lp/VwL/MwttqnkklBR1HEMkQmNYSnAbYTAYDNVg1oRBa30PMFzkIa8DvqWFrUC7UmrJ7LSudolEwK8ijmMAGocPAyaUZDAYqkMt5RiWAQdd1wes23JQSl2plNqmlNq20ErkZhMOW+UwGhrEMQANxw8BxjEYDIbqUEvCoPLclndtr9b6q1rrzVrrzT09PVVu1twSiYBPW45h5UrweGg8JvpphMFgMFSDWhKGAaDfdb0PODRHbakZIhGr5HZjo7iG/n4aj+4HTCjJYDBUh1oShi3AO63ZSecAY1rrw3PdqLkmHAZfKkR6jurq1TQcEmEwjsFgMFSDWdvBTSl1O3A+0K2UGgCuBeoBtNY3A78A/gp4DggDl81W22qVRAKSSfBrlzCsWUPj408DRhgMBkN1mDVh0FpfOsX9GrhqlpozL0jvxZDlGBqHfw+YUJLBYKgOtRRKWtDs2gUPPljec9K7tyWDpAskrVlDA6IIxjEYDIZqULZjUEoFgKjWOlmF9ixYrr0WnnoKtm8v/Tnp/Z6TE45j6O+XTXswwmAwGKrDlI5BKeVRSr1VKfVzpdQxYBdwWCm1XSn1n0qptdVv5vxnbEz+yiEdSpp0CUMgkBYGE0oyGAzVoJRQ0u+BNcDHgF6tdb/WehFwHrAV+A+l1Nur2MYFQTDodPSlkg4luYWhqcmEkgwGQ1UpJZT0Cq11zl5hWuth4EfAj5RS9RVv2QIjGIRQqLznpENJk+MZwmBCSQaDoZpM6RhsUbDWF7xdKXWNdX25Uuos92MMhQkGJfQzOVn6c5xZScEMYfCSwutJmVCSwWCoCuXMSvoy8GLAnnY6AXyp4i1aoASDclmOa0iHkuxaSSAb9gAN3qRxDAaDoSqUIwxna62vAqIAWusRoKEqrVqA2IIwHWFIl8SAtDA0eieNMBgMhqpQjjAklFJerMJ2SqkeIFWVVi0wUqnpCUM6lETEEYb6eimk5500oSSDwVAVyhGGLwI/BhYppa4H7gM+XZVWLTAiEdBWndhyZiZlhJJsYVBKZiZ5jGMwGAzVoeQFblrr7yilHgEuREpkv15rvbNqLVtA2PkFqEAoCWRmUjJhhMFgMFSFslY+a613IQvcDGXgFoNph5IaXOmcpiYawwkTSjIYDFVhSmFQSk3gbJijsv/XWrdWqW0Lhpk4hob6FJ6EznEMDRHjGAwGQ3WYUhi01i2z0ZCFzEyEwd+UggS5oSQVM8JgMBiqQsmhJKVUE/DPwLmIa7gXuFlrHa1S2xYMbmEoJ/kcDoOvwapVmC0MxE0oyWAwVIVyZiV9C9gI/Bfw38AG4H+r0aiFxnRzDJEI+OrzCIPPRwPGMRgMhupQTvL5RK31qa7rv1dKPV7pBi1EphtKCofB32jV0Mh2DDrGcSMMBoOhCpTjGB619mIGQCl1NnB/5Zu08CgmDLfcAmvWOOsc3EQi4KuzhCF7VpKOmFCSwWCoCuU4hrOBdyqlDljXlwM7lVJPIrOTTql46xYItjDUkSAUrEMmdAnbt8OePTAyAp2dmc+LRMBfb9UnzJ6VlDKhJIPBUB3KEYaLqtaKBY7tEro5Tii4CPCm7xsfl8vDh3OFIRyGrjrLFmSHklIRIwyGohw8CC0t0N4+1y0xzDfKWfm8v5oNWcgEg+BXYVr0BOGJLgoJw8aNmc+LRMDnze8YGlMmlGQozmteA+edB18yNZANZVLOdNXNwL8BK6zn2QvcTAhpCoJBaFYhAjpEaCKz7qAtDEeO5D4vEgF/m2ULsmclJY1jMBRncBCOHZvrVhjmI+WEkr4DfAh4ElNVtSxsYfATJjSRmWV2O4ZswmHwdRYIJSXDRhgMRYnFnHpbBkM5lCMMg1rrLVVryTzm/vth6VJYtSr//aEQBHSIACEmQpnCMDEhl/mEIRIBn8daP5g9K2kyRFxr3Ilsg8GNEQbDdClHGK5VSt0K3A2kx6pa6zsr3qp5xqWXwiteAV//ev77g0Fo1hMECHEka7rqlKEkTxS8XvmzaWqigRjJpCKZzLzLYLAxwmCYLuUIw2XAeqAeJ5SkgRe8MBw/DkePFr4/GNS06HEChAhHMkf4hUJJyaSc2D6imWEksEpiyBNjMfD7Z/oJDAuNyUk5howwGKZDOcJwqtZ6U9VaMk+Jx+XkGx4u/JjghGYJQQKECEWcNYWpVOFQUtSKIPlUpIAwxNLvb4TBkI2dfzLCYJgO5ax83qqU2jCTN1NKXaSUelop9ZxS6qN57l+ulPq9UupRpdQTSqm/msn7zQZjY3I5NFT4MaEgBLCSzy5hCIVkxbNSucLgbNJTXBhMAtqQDyMMhplQjjCcCzxmdexPKKWeVEo9UeqTrf2ivwS8GinAd2keofkE8AOt9WnAW4Avl9G+OaEUYQgGodl2DFFvuvyFHUZauVL+d1deTW/So8O5wuDz0YDMVjLCYMiHEQbDTJjNlc9nAc9prfcAKKW+B7wO2OF6jAbsjX/agEMzfM+qMzoqlyMjFEwEB0OOMKS0h1gMmpocYVi3DvbulQT06tVyW3q/Zx3OnJEEOaEkgyEbIwyGmVCyY7BWPo8Di5FFbvZfqSwDDrquD1i3ubkOeLtSagD4BfDefC+klLpSKbVNKbVtcHCwjCZUHtsxaO2IhJtkEiJRT1oYwCmRYQvDiSfKpTucZDsGvw6ZUJKhbOwclREGw3QoWRiUUlcA9wC/Aj5pXV5Xxnvlm3CfXVP0UuA2rXUf8FfA/yqlctqotf6q1nqz1npzT09PGU2oPG4xyJeAtjv4AKG0MNi3ZQuDe8pq2jGk8guDCSUZimEfF8kkJBJz2xbD/KOcHMP7gTOB/VrrC4DTgHKG6wNAv+t6H7mhor8HfgCgtX4QaAK6y3iPWcd2DJA/z2BXVi3XMaSFIRmcclaSwZCNe8BgXIOhXMoRhqi9jadSqlFrvQs4sYznPwysVUqtUko1IMnl7JXUB4ALrfc4CRGGuY0VTUE5wuBHrEK2MKxeLbmJvKGk5IQJJRnKxgiDYSaUk3weUEq1Az8BfqOUGqGM5LDWelIp9R4kBOUFvq613q6U+hSwzSq3cTVwi1LqA0iY6V1a59vCpnZwh5Km6xja22Hx4jIcg5mVZJiCqGsndiMMhnIpp+z2Jda/1ymlfo/MHvpVOW+mtf4FklR233aN6/8dwEvKec25ZmxU4yFFCm/eHIMtAu4cQ7YwtLTAkiWZOQZbZFqTI9DQlPmiJpRkmALjGAwzoZzk85uUUi3W1ZciJTI2FnnKC4KxkSRLOYSHZMmOwZ189vmgrg56ezMdw8MPQ3c39KUOmFCSoWyMMBhmQjk5hv+jtZ5QSp0LvBL4JnBzdZo1fxgdStHBCB2esamFQckZ6nYMrdaqjSVLMoVh61Y45xxQ8ZiZlWQoGyMMhplQjjAkrcvXADdrrX8KNBR5/AuCsdEU7YzSyfDUyedWidwVEoZjx6T42ego7NwpwkAsvzCYUJKhGG5hcK+oNxhKoRxheF4p9RXgzcAvlFKNZT5/QTI6Cm2M0ZUaZHg4N0+ekWPoaMi4LVsYtJZdt/70J7mtoDA0NppQkqEoJvlsmAnldOxvRpLNF2mtR4FOZEe3FzRj40qEgSGGBnM3tstwDB3SwecTht5euTx8WMJISsGZZ5JfGDweGhpkvaARBkM+TCjJMBPKmZUUxtp7QSnVq7U+DOTZd+yFxdiEh3ZG8ZLkyeO5jiEYBKU0Ph1BdbbRpKKEQjLLaHzc2fVtyRK5tIVh40ZLNOLx3FpJQGOTgrgJJdUK732v/Eyf/exct0QwwmCYCdMNBf1i6ocsfLSG0Qmv4xiGc6t+BIPQXB+XeiBtbQQ8kYxZSe5QEjjCcM451hvE47mOAUsYMI6hVnjgAXjoobluhYMRBsNMKGeBmxuz0TCS1EumxDH4iBCKeHMiP6EQBOpjoOshEJA9GUIdQKYwLF4sl/fcI5VazzkHxw7kEYa6JvnpjDDUBvbeGrWCyTEYZsJ0HcMtFW3FPMVe9Ww7BsgtpCeOwaqz7fPJngxWJ+IWhqYm6OiAu+6S6+nEM+QVBuVrotETN6GkGiEUqq3ZP7FIinprSrMRBkO5lOwYrFlIfwOsBOqUUtcAaK0/VZ2m1T52naQ2xlBWodihIScsBJYw1EWh3hIGLcIQjcrUVFsYQJ63Y4fcdtJJwFBhYaCpiUZPgljsBT9juCaQXNJct8IhFk7SwgSjtBOJ5NkkxGAoQjmO4afIxjqTQMj194LFFoZ2RtOOIXstQzAIzV5re06fj4CeIBRyymFkCwPAWWeBx0NRx0BTEw0qYUJJNULtOYYkTUTxqahxDIayKSfH0Ke1nukubgsKdyipCQnqZoeSQiHo9EQkVuT3E9BBBkOaiQkZXrqFwZ6yes451g12nCjPrCR8PhqVCSXVAvG47HlQS8IQDaVoJIZPR4hEAnPdHMM8oxzH8IBSalPVWjIPSYeS1ASdHrmSzzEEVDjtGPyECQdTRR1DWhimcAyNKm4cQw1gr0uJRCCVu5RlTohFLWEgTCRSQ1lxw7ygHMdwLvAupdReIIbMTNJa61Oq0rJ5gO0Y2n0xWhsSMFoglKRCOcnnfMJw4onysFKFoQEjDLVAyBVQjUbB75+7ttjEIppGYqTwEAkmmf4ERMMLkXKOlldXrRXzlLRjaE7i89XTOB5naCgz7BMMQrM/6OQYigjDu94FF10EXV3WDVM5BmImlFQD2KvbQVxDTQhDVKfDm5FgjdgYw7yhnJXP+6vZkPnI2BjUeybx+RWqrZWuoxMMDXVlPCYUgmZf0OUYhgiFVV5hqKuDvj7Xk6cSBh01jqEGcDuGcNgl7HNILCaOQaGJhJJTP8FgcDFljkEpdZ91OaGUGnf9TSilxqvfxNpldBTa6kKo5gC0tdHpGctIPicS0rcHdDAjlBSJetJhKLcw5DBVKCkVM8JQA2QLQy0QjWLlGCJEQibHYCiPKR2D1vpc67Jlqse+0BgbgzZvSGIHbW10qWGGhlan77c7jObUeEYoCeDoUbmvqDBMNStJR4iaUNKc4w4l1YowxGLQTYx6Eoyb5LOhTEpxDFMu2ynlMQuR0VFo9447wqAHM5LP6cqqqfG0Y/AjPcfhw1Bfn98MpJkqlJSKGMdQA9SiY4jFleMY5nAdg9Zw/fXw3HNz1wZD+ZQyXfX3Sqn3KqWWu29USjUopV6ulPom8HfVaV5tMzYGbWocAhJK6po8liEMaccwOZrjGA4fFrdQVFKnCiXpGLGYGQ3ONbUqDE1ERRiiczduGxmBT3wCbrttzppgmAalCMNFyO5ttyulDimldiil9gDPApcCn9Na31bFNtYsY2PQrkcdx5A4wvCwThdTsx1DYHIsI8cAjjAUpZRZSUYY5pzphJJ++1t41aukLEo1iMY9jmOYQ2GwRfOZZ+asCYZpUEqOIQp8GfiyUqoe6AYi1mY9L2hGR6HNJQydepBEQhEMQkuLK5Q0OQqNXTnCYFdULUgJwhCLGmGYa6bjGO69F37zG9i/H9asqXybYgkRhnoSROJzVyvJCMP8pKzqqlrrhNb6sBEFYWwM2pLDTigpq15SWhjiwzmO4dixMhxDvuSzWeBWM0xHGOw1MM8+W/n2AMQSXhqJ4Sc8p8Jgfx/PPls7q8INU/OC37N5uiSTMDEB7ZPHnVBSljA4OYaRnORzKlWCMBTZj8EscKsdphNKsoWhWknZ2KQnnWOIT3pJztFSBvscCIfh0KG5aYOhfIwwTBN7gVrb5PEcx2CvZUjnGAjlJJ9hhjkGn09CScYxzDmhkIQOofS9D6rpGFIpiCfr0jmGctpVaUJDzo5BJpw0fzDCME3cezGkcwyIIuSEkrAWuDU2EsAZUpYsDPX1uffZoaT4C3KmcE0RCkF3t/xfsmM4KCOLZ5+pfI4obTRVAp83AcydMISPO1/I00/PTRsM5VOyMCilNiulfqyU+rNS6gml1JNKqSeq2bhaJl1Aj9GCoaQMYWhsBKUINDmeviRhsJ6XgxVKSkx6Kr6l5COPwA9/WNnXXMgEg9DcDD5fGcLwvBwczz1d+RhP2mjWJ/E1SmB/zhzDaCL9v3EM84dyHMN3gG8gu7j9NXCxdVkySqmLlFJPK6WeU0p9tMBj3mxNid2ulPpuOa8/m2Q4BiuUlO0YQiGoq9M0EBfHAAR8TgauZGHIhyUMQMXzDDfdBO99b2VfcyETCokw+P1lCENEXODeA56KT1m1haGpPomvSUYNc+YYxuTgXNQ4aoRhHlFOddVBrfWW6b6RUsoLfAl4JTAAPKyU2qK13uF6zFrgY8BLtNYjSqlF032/apPPMdQzSWtTjOFh6cyDQRECNUG6g2/yKdRICo0nHZcuSCyWf0YSpENJ9sOKrqAuk9FRWZhkKI1QSMYGZQlDtBE/IcLJAPv2wQknVK49acdQl5p7xzAmqnea72meeebsuWmEoWzKcQzXKqVuVUpdqpR6g/1XxvPPAp7TWu/RWseB7yFbhbp5N/AlrfUIgNb6WBmvP6vk5Biam8HjoaspxPPPy33BIDT7rFCB5RhUwI+/Tjr0kmYlzYFjGBuTzsVsCVkadiipLGGI+ziNR4HKJ6CjVr63sUHj80sYcs6EYVyE6UXeJ9i7t/LHqqE6lCMMlwEvQlZC/zVOOKlUlgEHXdcHrNvcrAPWKaXuV0ptVUrl3UpUKXWlUmqbUmrb4OBgGU2YmngcPvax3C06s8kJJSkFra2cs2gPP/whvPOd8PzzucKAz0fAK2fujEJJ1qwk+2GVxJ5xZVxDaYRCENi/A1/wWEnCEI1CPFXPZrYBlZ+y6kxm0/h88v+chZKCSeqJszH+GMkk7N07N+0wlEc5oaRTtdYz2doz3/SZ7LRpHbAWOB/oA+5VSp2cvaBOa/1V4KsAmzdvrmjq9cEH4T/+A9avh78rUgHKvd9zemeWtjZuO/PLrH3L17n+elnrcMaJVgDZ7uB9PgKeCNA+4xyDO5RUSWzRGx2FpUsr+9oLkWAQAuO78MdOIByeOvppC+9anqWlLsyzz1Z2Z5+0MDRofAEZ+82ZY5jQBAixLiTu6JlnZKdCQ21TjmPYqpTaMIP3GgD6Xdf7gOwlLwPAT60V1nuBpxGhmDV275bL/VNsSzQ2Bv7GSeqZdIShtZWG4DCf/CQ89BCcdhqcttrqBdyOQUXshxdnjpLPtjAYx1AaoZBU0PUTLskxuN3mCfX7Kx5KSiefG5l7YQiBnzBrU7sAMzNpvlCOMJwLPGbNKprOdNWHgbVKqVVKqQbgLUB2MvsnwAUASqluJLS0p4z3mDG2MBw4UPxxY2PQ7rN65EBALtva0mf9GWfAn/8Mt/yzjJQyHIOSRW6VEoZKOoZUqvZDST/7GXzpS3PdCiGVkrxCYHIMfypUtjCsTT5d8VBSOsfQCL5mKYcxZ6GksCzw7GSE7o5JIwzzhJJCSdZ+C/8ATHt7T631pFLqPcCvAC/wda31dqXUp4Bt1oynXwGvUkrtQCq6fkhrPVT4VSvPHkuGpnIMo6PQ1mSdga5QUs66f/ssdTkGuyxGScJQ4qykShEMkl4XMVqjFbFuuQUefRSuumquWyIdrtaWMOiJkjrgDGGIP8WP9r6ORELlXcc4HdKhpCaFr6Uu3c65IBTxEEDWbKzri/DMM2a/r/lAScKgtdZKqc9prc+YyZtprX8B/CLrtmvc7wN80PqbE8oJJbU1Wp2+2zHs3Jn5wOyyFj6fbPVJibOS7NfOpq6ORs8kpCobSrI7LahdxzA0RMa+F3NJuh5WYgS/mijPMbR7OGH0OZJJxb59sLZCQdNaEoZw1JMeCK1bNMqvdxphmA+Um2M4s2otqRHcoaRiK4pHR6G93uoF7KkfrlBSmjyOIZAKopTV599xB7zsZeStcjbFAgX7rko6hvkgDMPDEqKIRqd+bLWxhSGQGME/OV6aMIzKgdW2bjFrkQRDJfMM6RyDD3ytYkMi4bkpzx6KetP1wdZ1HOPQocyig4bapBxhuAARh90LtSTG6Kh0OsuXy8l1LGsVxfg4JKwV/mNj0FYfkjpGdgzAFga3oqTPUrcwjNPSAh4PcPfdcM89EhvJZgphsKNML0RhcF/OJe5Cif5UkHAJHfDYcbF4bSf3pYWhknmGtGPweWlqk+MnEpyb8qqheIbtR0gAACAASURBVB1+rzRonV8W+FSr1LihcpQjDK8GVgMvZ5olMWodO79wwQVy6Q4nhcMiGJ2dcPHFskahzRvMDPW0tcmWXG7f7s4EAvh8XJK6k3/+Z+v+gQG5/PWvcxtUomOoViipFnMMWjuCUAvhpHQoiSB+wkSjasp9B8YGrQWOm1bSw3FaGqIV7SzTh5zPgwr4aSJCZCJR/ElVIhyvJ9CUgvp61tXLIgaTgK59ShYGrfV+oB1ncVu7dduCwQ4jvfzlcukWhp07pdM85xw5sEMhWN102Ek8gwgDZPaueRzDxZM/4f9db/UeMxGGJlkaUsmQit30hobadAzBoOPaasExpENJhEoucT12fJIAQbzdHahlS1nbcqQqoaRGvxcCAdnec6JKe4hOQShRT6AhAV1dnJASRTDCUPuUU131/UghvUXW37eVUguq1Fq2Y3BPWd2+XS7/+7/lwD52DP51zY+nFga717bjPnY+wr7drp/xwAO5wddis5KApYExWurC3HJL5XbHspu+YkVtCoNbDGrBMWSEkqwk61R5hrGRpCyMbG6G5ctZ691bnVCS3wt+vwjDXIWSJhvxN05Cdze+0cN0dMDRo3PSFEMZlBNK+nvgbK31NdZMonOQ2kYLht27pa5+f7/MGHI7hqeekj7a3p+3pwe8kTyhJMgVBnfpbHeNgmgUjh+H88+XYfAf/5jZoGK1koC2wCSfXX8rv/sd3Hzz9D5zNvYahhUrajOUVGvCkB1KghKEYVSLMLS0wPLlnJDYyb59jhOaKfY+4E0Bl2MIzv6+mlpDONlIoDEJXV0wNGRfGGqccoRBIWsLbJLkL3Mxb9m92+n4ly/PFIbt2+Gkk6DOPcE3HC4tlOTu3N3CYLuFt7xFQk3Z4aSpyqY2NXFF90/4y7+ED33IcTwzYWwMvF4phVHrjqHWQkmlCsP4OI4w9PezduLPFa0jFA2nUKSo8zc4whCefWGIxyFJHf6mlIy4jh83wjBPKEcYvgE8pJS6Tin1SWAr8PXqNGtu2LPHEYYVKzJDSU89BRs3Zj2hFGGIRp38AmQKg51fOOEEmbL6m99kvv5UwuDzoWJRbr1VJkZddtnMQ0pjY+KWOjtrUxjcnUotdDDuzZhKdgzjngzHsG5S4pSVyjPEQpM0EkM1NYLfj5/wnExXtb+HgC+V4RhqQdANxSkn+XwTUmF1GBgCLtNaf65aDas2O3bA+97nzOiJx0UIVq+W6ytWOI5hfFzuO3lDKnMqql2I36aQYygkDLZjWLYMXvlKyXAftArQTk5KLz+FYyAapa8PPv95mfX69TxSvW0bHDlS/PuwGRuTEFVHaCAj0Vsr2J1KnTdVNWGIx+Ev/gJe8hJ4//vhf/+38Nz76TiGsaA3M8dgTVmtVFI2FklKuZSmprRjKLUceCVJfzd+LY5haIjOTl0Tgm4oTjnJ50ZgPdCMNTtJKXVN8WfVLvv3w3/9F/zyl871VCrTMYyMwMSEiAjAxv98F3z7286LlOoYCoWSbMewbBm86lXyv+0asldM58MSBpBKsGeeCTfckLlW7uBB6eCuv77wy7gZG4O20CHaf3hrzkepBWxhWO3ZV7UOZs8eqbJ75AjcequUUL/ppvyPDQah3puknsm0MEw5Kylcn+EYuhiiozleOccQTtFENEMYItHpR30ff1y+g3J3mrOFwR9QIgyTk3Q1x40wzAPKCSX9FNlYZxIIuf7mJa98pSSQ7X7ejs+7cwwggmHPSDp57D4ZftuEw5mOoaVFksylOIZwWIShrU2ed/LJ0Nvr5BlsYSgyK8ktDEpJnuHZZ2GLqzThpz8tI+DDh6f4QizGxqBNjdEREtGqZDjp9tulbTOZlTI0BH5PhKX6UNVCEnas/1vfErfY3V34+wuFoLlRbFXJjiHakOEYFLC2c7hijiEaToljaGx0ZiXNQBh++UtxTaUeQzbpUFKzklAS0NUUYmLCbNhT65SzH0Of1jrvxjnzkbo6yfl+9avSGdprGNyhJJAQ0vbtUmJ7ZWyfE+oBq6awyzF4PNLJF3MM9uNtx9DXJ9eVEtfw85/LkL9MxwDwhjdI+2+4AV7/emn7174m95W6n9HYGCzXY3TEJfZUKWEYGIC3vtW5vmoV3HYbvPSl5b3O8DB0esfomjzGziFNNeY/2MKwapUk4q0oSF5CIQjUSy9XijAkEhBJ1NNWF5aDsLMT/H7W+Qf44zO9FWl/LJrKCSVFYt5pv54twCMjMmOvVGRbzzoCLR7o7gSgq24M6GR4WMZBhtqkHMfwgFJqJhv11Bxvf7v0vz/6kQhDUxMsWSL32cKwf78knjcsOo4H7YR/IDeUBLn1kooln59/XsJINhddJD3Q1q3OkKoMYfB64YMflKfff7+Ej5SCs86SWbGlMDYGbclh2cuayk1ZtcuLfOpTcOON8r3mW9M3FcPD0KWG6dTHGSrxM5XL3r3ytdsdV2dn4YRpMAiBOhHxUoQhXUDPrsyrlOQZPM9x8GBlit3FItoRBtsxxMs51TNxC0M5hEes76XFm3YMnZ7RjNc01Cbl7sfwyAz2Y6g5zjxTJgR95zsSSlq92qpfhHQK9fVOKGljwMpEu5PD+aqftrdn9qbFpqu6HQPAa14joaM77yzNMfh8OT3JZZfJOfihD8E3vgFXXCEbBpXjGNomj9OB9AKVcgy2MF1wAVx9dfHOthjDw9CZGqKLIYZHihc6nC5798LKlc6xUGyKZSgEzd4otLTg80pIqRRhaPW5Avb9/ayLPglUpmZSLKYlx9DYCPX1+DwxIolyggOZ2L9TuYOEkCUMgbY6sV1Al5YDweQZaptyayWtBV7FAqmVpJS4ht//XnZcs8NIIJ1Cfz889phssbBRPyV3HD0qgmCf/dmOYdGizF64kGOYmJDsplsYWlvhFa+AH/+4vFCSq3f0+2Wfgq1bxUF87GOSSxkamnoqq9bWHPvYYMWFwe4IrIEjnZ3T6xyGhjSdyWN0MUQioapSqXPPHgkj2RQTsVAI2ao1EJAkKyU6hoBLGJYvZ+3ow0BlpqzGojiOAfDVJysiDOUeC6ERK8TWVufkGJJiHY0w1DZl1Uqy/4CY6/95zdveJh3i4cNO4tlmxQr4wx/k/5ODW0VJtJYQUCFh6O3NnBtayDHs3Ss9tTuUBHDJJXLfQw/J9amEAXIyee95j+Q1//mfRXe6u+WtphrxhUKS3mhLDqWFoVKhJLsjsAaO057PPjwEnXqIToYzXreS7N2bKQzFHEMwCAElkxCaAhLHL0kYml1Tx5YvZ+3wVqAyU1ajMZzkM+CrnySabJi2u7I/e9mhpDERv0B7g4RYvV66YocyXtNQm0w38PiLqR8yPzjhBDj7bPk/nzDYA/eNR38nMRmQcFJ6knZWKKm3V1TGPgsLOQZ7aOh2DACvfa3Yldtvl+tTzUqy38NFT4/kTG64Qa7bnfFU4SS7HEYbYzQRpaEuWXHH0NEhl9NxDFrD8Ah0IaEk9+tWitFR+ct2DKFQ/vLmoRA0K1nPogJ+/N5oUWFIf8ctLvu2fDmtTLC4e7IyjiGmMh1Do7zXdIstTtsx2MLQaZWE6eqiKzKQ8ZqG2mS6wrCgSmG8/e1ymS0M9pTVluYU/ZN7pKYRSG6gmGOIRCRUBLnTVe3/CwnDokVw3nmOVSnFMeQ54xctcsp39PTI5VQJ6HT8m3EU0OGPVTTH0N7utGk6jiEUgkRC0clwWhgq3cHYM5LcYUU7/JXvvUIhZEe+QEDCSd5YaY6h3XUKWcfAuqXBijiGWJy8wjDdxPa0hWFcXJG/wzqGu7sJjD5Pfb1xDLXOdIXhloq2Yo657DL4zGfgwgszb7dnJm3snxAltIXh4MHiwgBOOCl7uqrHI9ft+bHZwgAy79ROCExTGNyU6hjcexEDdDRGKuoY7A4WpucY7Md3Mly1UJJ7qqpNZ2fm+7sJBiGQmpDjIBDAr4o7hvR33OE69axjYG3H8co4hrjHST4DviZxr9MRBrvWI0wjlBRMUkeChnbrHOnuRg2ZeknzgWkJg9b6y0qpqXYsnjcEAvDhD+f2wbYwnNwlcVFOPVWGvVOFksARhmzHABJOskNMdmzFzSWXOP9XQBjKdQy2MLTXhyqaY3ALQ1eXdKrlLHSyR67VDCXlE4apHENzatxxDCpStANOf8edrnUFVp5pnW+Ao0edcNN0iSY8mY7BNRGuXNyfuexZSRNapvDa54ipsDpvmJYwKKX+CXiLUurbUz54HmN3Dpsan5FY/7JlMrqbiWMA50zt63PKcbvp75e5tDD1dFWY8oyftmPwjlfUMdjtAGcUXk4oyH6s2zFUI5TU1pap14UcQyJhzVhOuoSBcHHHMKrxEaa+zXXctLRAWxtrlcxVnco1xGIy7Xfr1gL328JgOwbXmspycX/mkeHystfhsJb9nv2OY7ArrJocQ20z3VBSCEgh5TEWLKtXwx13wOWBHzjLYPv7M4WhmGNIpaT3yOcYIH8YyeYNb8j/+m5KdAw+n7xMWY6ho4MONVqSMIyOyqK1Yh1PPscA0xeGeiZpbYhUxTG43QIUbmt6L4bEiEsYQsWFYTjp1Ely09/PupisZZgqz7Bvn6Sgfvaz/PfHEt5Mx+CX03wmjqGTIUYGyzvdQyElwpDlGEwhvdpnusIwBCwDnq9gW2qSN74RmvdvdzLT/f2SfE5XCMtyDJ2dkmE9cqTwWoRShOF974Mf/lBWWhWiRGEAGayV5RhWrqRdj2SED556Cq69NndR2c9/Lgvq3ltkP7/jx3NzDFBeSMGdY8Dvp7MxVD1h2Ls3XY2wUFvT0cTEqHR+fj/+VLC4MAxN0sp4rjD09bFm9BFgasdg/467duW/PzbpzcwxBGYuDGvYXX7yOaIyQ0nd3ZBI0NWSMMJQ40xXGM4G7gfWVbAttYnWkig+4QS53t8vZ6Z9xmQLg8cDixeLMNgddiHHkL2GwY3fD3/zN8XbVqYwlOIYFCmaA0BPDx3JQUZHnTz4zTdLSYvsDsKOmn3ta7LaOpt4XPIJFXMMnjFYsoSu+vGKdjBaW8KwLC67Mn3iE4D0aw0NhR1DIDacdgy+5BSOYaSAY+jrw/f8cyxfPrVjKCYMWkMs6aXRM5kOU/qaJZ8xY2EYL6+7CEc94hjsgZG9yM0XZmioOqvWDZVhusnna5B9Ga6obHNqkMFB6dXcjgGcszdfqMde5GY7humEkkqhVGG4/HJ6Jg+VJAyt9VE8ne3Q3k5H/BiplDPz1i4sm11l88gRacrLXy6L6h5/PPP+7FXPMD3HMDwM/roYTe1N0N5Ol2ekorFqW8tXdY7Jb/f5z8OhQyiVfxZVepMe7coxJCcIF9kUZ2wUp7Kqm74+OHqUtWtSJTuGZ5/NLLEO1jYe2kNjvXOHr0XmCM9UGGIJb1mvEYp6CXijTh7NLovRMEE87girofaYdmUtrfWfWUAL3dJoDQ884Jxx9rRSWxjszvzpp+XS7uTd2MJgd9jTCSWVgi0MxYaoR4/CN75B9+jukkJJbXVBmXnV0UFHzKmwmkg4HX72pj9HjshHvv126UDf+MbMjW2yVz3D9BzD0BB0NgQlO9zaSicjFXUM6TUM7daLRqPwf/9vur0FQ0l2HN3OMRTp8MbGVUHHALBumaxlKDaatn/HeFzyDW7S0cs6ZwFd2jFM5OYIrrsOzj23sGgMDUGDitOHLEwrZ2ZSKFaHv8417cx2DHWmkF6tM/2Si8LSirSilvja12Rnm09/Wq7bVc2yHcOuXdIxe/J8hbPlGOxQVHbv4Oa++wDoSZTmGNo8EzIlp72d9rBM0x0dlc2KbJ3L5xh6e2VR3c03y1d2zz3O/fb7uh1Dc7OkYsp1DJ1142lh6NLHqyIMq3zWhhFnnAG33AK7d+etl2SLX6YwhIs7hqCnqDCsbT/O6Gjx78Ut8NnhpLQw1LuEoU1Wz0dGc5du/+QnUon3gx/M/17Dw9DlGZ1W7axwop6AWxiskUGnrl45E0NlmFIYlFL/pZS6Uin1YqVU1tFMWVFCpdRFVnXW55RSHy3yuDcqpbRSanM5rz9jjh+Hj3xErO8NN0it6N275bo9VcXuzI8eLTxjqLdXnmsPKQs5hmI5hlKwNpNPbzGXD0sYusMHCAaLR53Gx6FVj6eFoSMpPdDISOb+RIUcA0hfCs62qJA/lGRVSCg7x9ClRsTRtLXRNXmU0dHccMp0sYVhZb01p+Kmm6TE7nXXFXUMzQQzhSFSuDDAeMhbVBhO9Ev13kKJZRBhsKfTFhKGpgaXMLTWAxAZz9ynNRqVysG2oP/gB7nvNTwsM5LsMuzlCEMo0YC/wfWedijJFNKreUpxDE8CpwD/AexTSu1VSm1RSl0PZAtFQZRSXuBLSJXWDcClSqkNeR7XArwPeKjU164YH/6w9I4//KF463//dxGG/n6nc/f7nR4uO/Fs09srvZW9p3O2Y/D7Zbi8aNHM27xxo7PFXD5sxzAhIbFirmFsDNpSw9LxtrdnjBK3bZOBus9X2DGAU678wAHn/nzCAOWvfrY7qXQoKX4ErStX6G/vXmm/b8LaPOLkk2V22He+Q5dnuHDy2Z6r7/fjJ0w8rvKKVTIJwWh9/hyD5UTXeyR3NZUwrFsnCxezH5eOXrodQ7scu9nC8MQTkpP4wkW/5MUvlhLtduTUZnhY05mcXrXd8GQDgQZX+MoupBeXA8gIQ+0ypTBorb+qtX6P1vplWusu4DzgZmAc+FUZ73UW8JzWeo/WOg58D9kqNJt/B24Aplnya5rcd59MqfngB2UNwbvfLcOoe+/NLaJkh5OKOQZwhs3ZjuElL5H38E5/V600GzZI75CvJwoG4dFHobub7qSER4rlGWQvhiEZjnZ0ZGzWs22buIElSzKFIZEQsbE/sscjg99ShKFcxzA0BJ3JQSeUFH0+4/VnSnqq6tCQfJD2dhks1NXROfBkzkyaQqEkyB+zdxcpzHEMra3Q0sKK0A6amqYWhp4eWL++SCip0WmoLQzhrBzDn/8sl+fc+WFu/66mrk72DnczdCxJJ8PTEoZQsolAo+s9rRl7XeNizUyOoXYpO8egtR7QWv9Ca/0ZrfXby3jqMsC1LyYD1m1plFKnAf1a6wJLd9KPu1IptU0ptW2w1B1oipFIwD/9k1TNu+Yaue3aa6VD378/VxjscFIxxwBO7D/bMVx+OXz/+zNvN4hjiEadOIibrVtFMN74RroRq1DcMWhHGFyO4ehRSTxv3izC4A4l2TuzubdpXLEiVxj8/tw8fTmOQWsrlJQ44oSS9GD69StBWhiOH5fvwOORRvb10RU/RCyW2eEXCiVB/vkAGetEsoUBoK8P76GDrFsHO3cWbmdJwuAqyutt8dNAjMhE5uDhkUeg0zvKiuBTrKg/xFVXybwLd5mS4SE9LWGIx2FS1+H3ZW0CsmwZnUMy7co4htplpsnncsgXeE0Pa5RSHuBzwNVTvZDlYjZrrTf32IWAZsKvfiWrtz77WccF9PbKqi0o7BimEgbbMWQLQyXZuFEu8+UZ7rtPOrc3vYkepBMtpKNaW47BWvVMezstTODxaO65R7Rz8xma3l6d4RhskXALw/LlmTmG7MVtNlM5hmTSWUMhlVWhM3bEcQxFKqzG4xIqKZVEQha0px2Du8H9/XSGZFaOuzOzhcFHpCxhaK2POmVm3fT1wcAAJ51U2DFo7QjDiSfKd+tuUzrH4HIM6X2fQ7nCcLr3cTkxt29n7Vp5ffdvNzzqoYsh2vtEyEoN26ULA/iy0pBLl9JweD/NzfNLGF7zGvi3f8t/30JcjzGbwjAAuLcS7wMOua63ACcDf1BK7QPOAbbMSgL6/vvlRH3NazJvv/pq2cnnta/NvL3UUJLtGIrVO5opJ50kl/nyDPfeK4X/TjppSscQjUpJ6zbG0tNVPWjafPH0DKPNAz9hyS+/wZEjzplw1JrAky0Mzz8v8WvI7WdtpnIMf/mXTmjDXZrBma5aeHbLjTdK6KvUva737xchWr06T4P7+uga25PRDpBQkr8hIXuB2wvcEEtR1DH4ClQOdAnD3r35w1ETEyJ6PYceZ32/KJM9cxpcOYYm1zjM3vc55PxusRg89ZTmjLhVcGnHjnSp8T3yUYlEIBLz0skwdSetpYXxkuslpQsDZAvDsmVw6NC8K6T3wAPw7W/nisC73y1VmSs1AaJWmE1heBhYq5RapZRqAN4CbLHv1FqPaa27tdYrtdYrga3Aa7XW2/K/XAV58EHZhCc71tHcLEfDhqwc+VSOoblZOorZcAytrdKebGFIJCSUdO65sGgRHd4JPCpV0DFk10mivR2ADp+Uke7shJXP/Zbe8G5GR1W60yrkGFIp2RIV8gjDyAi86EV0HdkunU+eDvDQIbj7bom4DQ1llcNoa5NQUpEKq3fcIcJU6v4Gjz4ql6eemqfBfX10Dj+X816hEDQ3WglduyRGKaGk5gK9SF8fHD7M+rVJtM7fdvv36/n2Tax/VDZzcruLdCjJfcjZjsE1jfapp2QgcAbW6bVjR3rinS0Mdtiok2FYv552Rhk5Wlo53HRiPivHzrJlMDxMV0eqJnMM27eTs11sIiFO6cCBzN8kGpW1O7//PXzxi7PTvnvvdRacVpNZEwat9STwHiRhvRP4gdZ6u1LqU0qp1xZ/dhWZnISHH4a/+IvSnzOVMIAE4+2zuJqOAUS4skNJjz0mvdN554HXi3dZL50NwYIj6ILC0CBn+ObNoPbvYwkSR7IFwb5cvNh5Lbtcua2L2ZVV+cQn4PHH6TwmPVq+DsIuEJdIiDi4S27T3g6trbQxhsejc56/d698fHCWoUzFtm1S9uLkk8nvGCaP5LQ1FIJAvdVRlpNjaEnl3mm9D6kUJ3XLcZMvnJQWBgZZefhBGhoKCYPr1LaFIeIIwyNSlokzeETCjdu3s2SJHKp2uipDjE88kQ5GGDmWObOpEOlQUnNWF7NUlj51BqIVcwzBIPzpTzN/nfFxOP10+O//zrzdfc785jfO/3/8oxwDK1ZImCl7RlelGR6WLWHe/vbqh69m0zFgJa3Xaa3XaK2vt267Rmu9Jc9jz58Vt/DEE3IUv/jFpT/HTj4Xq3zqHkJX0zGA5Bl27sz0s/feK5cveYlc9vXR4x0uXRgaGsDvp6NOhk9nnAHs359XGNrbMz+ivfOdnYDO6GcffVRme0F6VlE+YdiyReL9mzbB//5vZmVVO5TkQdMRiOd0MD/+sVwqVZ4wnHKKpeH5cgx5wlbBIDTXWT2xvVFPKcLQWuCstgYcaxv2o1T+BLRbGLxP72DduvzC0OR3ndp+Px2MsOtQazpn88gj0B6Is4q98uPu2IFHaVatchxDRm2qNWtEGIZKi5nY23r6s4XBWrvTVcECiF/9qhzmM93H4uGHJUznzrFAZl7u1792/r/rLvnZ775bpmhfcYWTE6sGO3fK62/ZAt/9bvXeB2ZZGGqSBx6Qy+kIQzHH4BaG2XAM0WjmCuj77pOAuTVCo6+Pbj1YWijJcgu0t9PukbNt8xka9u2jF1EEOwF95EimWwDHUB04IFo1PGz1s6kUvOc9cmX9ejrDuQldkFHYb38Lr3sdvOMdEhGz9x5wCwNAV56R5513Skho5crShEFr6SjPOAPSsS23xenryysMoRBSC6ipSaYelxpKaivQEOu48g0eYNWqqR0DO3eyfr0u4BhcOYZAgH/gK2w/0s0dd8hNjzwCp/cdk8TzK18psZIjR1i9OlcYutompagiI4yOlrarb3hEGhJozZqSbQuDd7RiwrBvnxh/90w4ELe5ZUvpo+uHrJVTdt7Mxp55d9JJEjZKJOQ1f/YzeMUrZG7KjTdKKfRbqri3pZ1LOuEEqWScvdC0khhhePBB6Tz7+6d+rE1jI3zyk/DmNxd+zGw7BnDyDJOT4hjOO895TF8f3fFDHD+e/yzJcQyQMWV185oRCIXyOgb3RwUxUl1dcqKOjspJ1NWFDP0feED2UV23Lm9CF8Sux2KS83/rW2Xk/7WvyX2dDKenqwJ0NWWOPI8ckbd4wxvkBCpFGHbvls+/eTP5F1309eEjiq8+kRtK8kacAYLXi79BRtT5hOHYMWhUVhHAfNgDDisBPZVjYGyM9cuC7NnjTDFNJ5/9rg65oYG3en/App4jfOIT0u4nn4QzOvdJGMnesnb7dlatku/Dnh4M0Nml0sJQaoXV0HABYbAGKl36OCMjlUna2sfiwEDm7XfdJYOLP/6xtNcpJAz2d/62t4lL3LpVcjT798Nf/7Xcd8UVks674YbpfYZS2LVLjPxPfyrH1z/+Y/VCSkYYHnxQ8gv5dlIrxjXXFHcZdm+plPjMamLPTLLzDN//vgRG3VuE9vXRkzzC4LH8R5Jtw1sbYk4SvqODc5oe49xzoX9SAs89DOJRqQzHkC0MIHHX/ftd/WxrXBaLnX22TDXq7aVrOP989i1bpO8/91wZYF54oXTc/oYETcREFKx1AF0NwYzO+qc/lZPlkktKFwa73EdBYVi0COrqckQoGIRmFc4IKdoakS0MWsu+FS9teCj/GgaQD+33w8AA69fLCDG74xwcBJ83RsByJif6DpBMOvHttGPwZ3bI3kAT/+/FW3juOVnDGY/DGU3b5cfbtEkeZM1MGh+XxHNaGHq80N0tyedQA6UQGpVchL8t69hvawO/n67Jo+kp0jPFFoaDBzNvt52Pu25XIbSeWhj+9m/FGP76104OzJ7IqJTo67594iiqwa5dsuJ9wwap7fjTn0ryuxq8sIXhyBHJtJUTRioVu7dsbCxfdMqlrU1Gm9u3S7jm058WF2EPZ0AcA8cZGlZ546B5wxzt7Vzu/x733iuJZwBvnYdFDWNFHQNInuHAAVdl1ciADJk/8AEZpfb2pmf6uDv2ZFJOur/6K0dP3/lOuez0RZxG1teDz0dn3TjPP++0/847RRBOPlku3R1cIbZtk59p40byC4PHIwuzvOPp15qclM64r+FYKEmLvwAAIABJREFUpjAE5LfOnmn1+OMiUm/y/LCwMCiVMWU1Fssf7+6pG4G1awFYnxSXaIeTYlH5cbOFgUCAv+p5mHPPlZg8wBnJP8kIfvFimXbmmrK6d698FfUqQWBRIJ1vCsUbSur4wmPyoEBHlpAoJd9lpHKr1gs5Bvu7K0UYDhwQQWhudkJHNoOD4PFoVvUEOesscbR33eUs+LRZtUpOv2yBqhRPPy1rV0BOo1e+0hkIVJoXtjA8+KBcVlMYqh1Gstm4URzDli1y+fGPZ1Z+7eujh0GSSZV3kVJ68VWna+FVe7szZ9HOX5x6Kr3eQQ4fllHxxERhYdi/31VZNWidpVaHxuLF+AnT1JS5zeNDD8mJ6F46csklMpDubAiJl7a/07Y2Ll7yCMePy8f/7nfhd7+Txyvl7K00lWvYtk1yEvX1FK7f0d9PF04110cflZDMeS2P5RWGbMdwxx3g9WouiX4vt06SG5cwQG44aXAQevSgJETa2jhxWI5h2yzGrEVsTc1ZC+j8flQkzGc+I1fb2pAd45YulS9rwwbYvj1jLcPwMHSqEVS3fBcdzdLZl7L6OWQJg789j8NYupSuiX1AZYTBdq/ZHbItDA8+OPUo3s5hXXSRHNNuYR8chC7PCN6r/pFXvUqS1Fu3wsUXZ76GPd03XxGCmRKPy0Bk/Xq57vXKutzLLqv8e4ERBuloTj+98q/tdgyzwYYN0otcf70knbPzH8uW5Sxy+93vZIRtW/pmbxhvp8sytLc7S13375eE7/r1LNHPc/hw/sVtNsuXS6jFDnF0jVr/2D2P9aTOlsy4/ZYtstbwoouc25qbZTrgm1b+yUmMA7S28qbu37N1q6RF3vY2Gcnb22WXIgyplNQM2mwvoywkDH19dCaOpdtqT/o6r+nhDGFoaG7AQzJDGLQWYbjgZSm69WBhx2C9jx1KgtwE9OCgpmfykMTYNmygZfdjrFwpOQOAaFBmAzX4s4QhEIBQiL/4C4nkvf71oA4fciYnWMUYV62UUKMIg6ZLO8vWO9rlvpKEYVycS6Azz/G/bFn6eJipMASDzrqDbMdw4ICc3uGws06lEA89JOONV7xCrrvDSceOaXqSR2DLFl75sjiplPymhYShWBX86bJnj7jpE9c5oeBqBiKMMJxxRnU677lwDJGIDH8/+tHckgtLltBjCcPgoNjl179edg89+2wZBaX3YrDp6BDFSKXkaF+5EpYsoTd+gCNHtLO4rXEE3v/+jGGWvZbBPiG7ju3MWB9hT2XqCsQyOoe77oKXvSx35s7HPw6fWPO9zDtaW2F8nDPPlFk2n/oUXHopnHUWEAyyeuCeKaesPvusjBDTwpBv8wiQtQyRAYaG5MS85x6ZjbJ08kCGMKjmAD5PPEMYnnhC3udNr7ZWfRUThv5+OHSIzrYkixblcQxHU/SkjoownHQS7NjBqac6myjFwknqiePxZx13y5ale6zbboPbvhqXA8EWhg0bYGSElvBRurstYRhM0qmdRSj2oVFKWYzwRBIvkzS055m5t3QpXccLr2EpxPHjud+H3YErUhzcl1kkcP9+p/O2hbwQDz0k40N3VX2bwSNJevQxmJjgrMgfaW2Vr+300xHVsZSpr09G8tNxDMPDcgoV+m7tAcL6j10C/+f/VH0hwwtXGOJx6Q2rEUYCp6T2bDoGkA7ADsq7qa+nu1sOpuPHpaJ4OAz/8R+yyvj++7OmqoL8b+/tuX+/9Pa9vSxJDnD0qFNVvHfn72Tpp2v1j72W4c9/Fo1qHdjhuAVwHENjKN05PP+8hERe/eoCn3FsLFMY2trSMbCGBjlfvvtdK4L2P/9D00Xn07ckWVQY7MSzvY8EQ0PS0Wf/bn19dKYGGR6Wr+S++6xJX6FQ5nqWQAC/J5IhDBJGgkteaingVI5hchKOHs07M2lwUMmMJMsxcOwYp66L8MwzosuxSJJGYrkDkk2b5MXsmIqt6m5hgHSeYe9eGB5MySww2zF0S96iJMcQ1PgJowJ5hGHZMjrj8v7lOIa3v13i6m7sMNJ6dnFwQKX7y/Fx6WTPOUecY7E8QyIhx+nZZzunbYYwHE2la43V/+KnfPKTMghRCpn29PrXA3Kc9/dPTxhuvVVOof/5n/z328Jw4qHfSeb5Ix+pqji8cIXhscckc1POiudyqK+XkdZsOYaTT5aO/JprCopR91K5/cEHZY3ZFVfI8fXMMzLN7uP1N2Y6BlskRkYyHMMSDpNMqvTs2N4hK8DtmhdoC8POndKvqD27M4XBdgx1Y+nO4e675fLCCwt8xtHRnFBSwVVNjz8OWnNCz9iUwtDU5Kp6UqiwU38/XQwxOal4+GF5WEFhUI4w2GGk88+HngYrkTNVjgHg4EHWr5fvzz7/w2EIRz2OMFiJiFPa9pNKyRTKWCRFE9HcY2DTJhkM2RtK2/VK7OypqxijvZZhaJgMYWhfLK9ZijCEw9opR57NsmW0M4rHo0sWhscfl5j6889n7hVt69uZPEwo4k0fDvaahuXL5Xe6777Ci8+eeEKm+Z59trMmJ0MYjisWcUyOvS1b+Jf3a/7+7xE7/NvfygDT+pFWrZqeMNgL1m6+Of8U3qefhiUdEVqZkHjXf/6nFPmskji8cIXh8GHpuKvlGEBGxbMlDC0tEh+68sqCD+lZIaO3m26SfuO66+R2vx8+dHWKt0W/lhtKAhGF8fG0Y7AXuT36qIzOew5bZUxdw7JFi2QUn0xCV5csjssQBqueVKdyNsC5+275SU45pcAHyHYMxYTBUq0TfANFheGRR6RMVjryllO/w6KvL12b6Sc/kZvyCoPfj1+H08Lw5JMivG96E04wvJhjcC0bP+kk6YTt6ZIZaxhcwnAqEkd64gkRhoKOwX4QOMJgO4beXun4rAT0/v1wfMQrn9kOJS2Vacwjg7l7R2cTCiGL/fIJw9KleNB0NifyLrg8cCB3sdp//qfzv3umllsYwElA249ZsUJ+p+HhwqXM7Wmqbsdgz0yanITh8Xr5zt/5TnkDO273hS/I5fh42rqsWlV+jmHHDnnJCy+Uz21PhXWzaxes77Aa9cMfykLRz37W2SagwrxwheF1r5Nf3z4xqsGppzoZqdlgivUS/pWL8BEmkYB//despPHEhAyp8jkGu/DQypUSSrIWuT32mJR/9u62Kov9+c/pjtrjcfq4ruaY+PXs8uW9vXQlj6U3wLn7brjggvzbaAP5Q0n5hCGZTPcCJ0zuYnAw/3z5ZDIr8QyFHYNr9fNPfiIjyxNOIL9j0CHCYelUbrxRPs8ll+BUPysmDHZyxhIGECcAWcKwZIk81udj9fE/0dwsnUs0rEUYsh3D+vUSz7Kz1NnCoFR6ZtuqVdL2aNybGUrqk885cihP1cMsQhGPs7NdNtbq5xMXDectCnzppfKb2J37/v3wve85Yzh3x3v4MHiZ5EXIMWonoN3C8NKXyv+F8gwPPSSCsGKF6Glbm+MYbEfTw6Dso6KUzJA4elQWEdiCax1vK1dKm/IVhizE7bfLMfLNb0ooKrtWk9aWMDTskZO2rU3iTh//eDqMVWleuMIA1V9f8M1vVr+oSTlYU1YXL0px9dVIp2YPbe34QHaOATKFYcmStGPYvx96e7Vkd08+WYTl/vvTT08LQ4PVIbodA8hahtgR4nFxH88/XySMBIUdQ7ad3r07PcH7hJFt6Zuy2blTvoJ0fgEKC8PixXR5RV127ZLORqWSEoNwd36BAH4d5OBBePnLZbH3Bz9ojURLEQa73Mf+/Zx9tnQYf/iD3JUWhraEdPweD6xfj2fXDjZtEmGIRXV+x9DYKOLgFoa6ukx3tGEDPPUUq1c536dbGBqXdOIjzMjhqTdXDNvCkM8xW+Gr07sO8NhjmSGeeFxc3OCgLMOZmIDPf15O1c9f9P8BmaGaI0dgsTrGcsRi2I7BnpG0eLEcdkuWFBeGs892uoPFix1hsJ1DD9ac6HPOEWG4+WZprF1W1UoC2OPA7PUnhdBauogLLxS9/Id/kOiUu5T64KBEUU+MPSEr3EAae/31WQdv5XhhC0O18XqLDH/ngL4+PsNHuP2GAVrqIjJ953XW7qq2MOQLJdnCsGIFtLfT2+AEmRe3x0Vc3vEO6Whc4SRbGLqVFSvKFobFi+mKyJlsb0RvTxfMYXJSQjHZOYZUKjPoDE5pkBe/mBOel7xHvnDSL38pl3ZFCKCwMHi9dC5yZnqddx6uEqJZjiEV5MknxY18+9uuMIgtDMVyDJDeAq+tTX6i3/5Wbk4LwxLXjLOsmUnRKPmFAWR06xaGJUsyj8/Nm2F4mNV1Thynk2HnOOjulnpJg1OvcAtFvfi9sfyDr8ZG6O7mtKadBIOZv8327aLpV1whIZY3vUnqD73lLbD5V9fTSJR9ex3hOnIoSa8+zBIO4yGZ4Rj6++XjKSW/1z335I4hxsakEz7rLOc2tzA4YhyX4/u1rxXl+sIXZBXmy14mx6HlGMpdy/CnP0k+521vk+tXXCHG/8tfdh6TnpE0/IAjDFWmhnotQ9Xp6+MtfJ8Llj0jCwN27JBeZ9cuZ55cvlDSjh1OASSlCCxppaVevHJvk/W8U0+FM8/Mm4DumjwqIpldj6q3l84J6YR+8APpD7O1I016w+SsUJL7PhtbGN78ZtZEJQ6TzzFs2QIvepETvSGZlO8hnzAAXcuczjadX4AcYTiVxznjtCSPPOKc8EBpOQbI2ALvwgul8xgfd3VS/a5Of8MGOHCAU9dHGRuD555vyp98BhEGO1906FBuGPWccwDo239/OufS2ZxwEjA9PVIWY2jqEqLhuJeAt8iy3GXLON0qnmzvPQ3OLLGPflT63l/9Sr7mD70vhmfbn1jJPvY96wjTkYEkSzhMfb2i13MsI8dgH38gv9fAQO5I3t5f4eSTndsWLcoVhkU9lqLYKy9HrCnaSpGeJYCYaig9z/Dd78pPZVevWbxYxPC225zDxXYP68e2GmEwVAErtst3vyv+/G//VoYnt9yS3zFYFUxJJKT3tEd/vb0sqZf5/r0ey2ufcILEVx5+ON1h2h1uV2RArmSvrVi8mK7gPkBGWBdeWCS6l69mh92+7ATC9u1yhp5zDgHCLOmI5jiGwUEptpexOd/IiKviXy4dK1rTb7tpEwUdw2f4KNt+eTxdviBNKaEkcOqJIA4qmRS9HRyEeuK0rnD9RvbMpGYZou4aaCnuGECSFvmEYeNGCASoe/hBR9Q7XCJgOYaREtYxhOL1zl4V+Vi2jA0Tf6KhIVcY2ttlgHDVVTJB4gMfgFNiUhN7JfvYt9tJfh8+goQ2Tz2V/tR+Bg7IlJ4DB1yCj5OfsPehsLEnadkL8qGAY7Bd2kknybG+YYMzd9a1F2v2nhb5mJyUw2xyUsqa/fVfW4eyZWfe+17R7g9/WB6/axf4GpP0c9AIg6EK2MLwjW/ImXfrrZK8+uY3nekd7lCN1+t0xPZQCKyZSXLm9CYOSoe/YoXY6snJdH2BdOcytie/FejtTSd0YYr8gu1oskNJkN8xbNyYnoN6QtuxHGH4+c8lCmVH0oDCq54tGlYsoYVxXvISjddLfsdg5xuyw1v2Z2hsnLqo4ooVMo0mGOTFL5aahr/9LQweTdLDIKpvmfNYSxg2JR9L35Q3+QzOdK8nn8wvDF6vuL6HHkr/XJ1dLqXu7LQqrGbVYcpDKNGAv75IyGnpUuoP7WfTpsxVydu2WZtCWW977bUyi87OXa1kH3sPSiedTMKx4ToRhjPPpI8BDu5NEo/Lx3MLgy3S7tg9OGGs7JnUIyOSQhgclMVzXX1WYUmlZNrQz372/7d37tFVVXce//5yb56ECIZwueTNIwFEeYUhVuwoAlJF0DVMrQK11kd1WkfG+qxdzrKrnU7Bpa0zU0dq8dHaYgtqEa3UAVaRqgWMikBAwvtNiBgISMjjN3/8zr7nnJtzHwkkgXt/n7VY5J6ce+/eOefs7/499m/bjRw6VL6wvh4pKfK9kYThD3+Q2IfPJ/ODQ4ekgjCWLpV7e9MmVFaKKDzzjNS12rwZKAvUyxayKgzKWScjQ4KNRGKrZmdLemtdnV3X2mkxAPZA7HzKgkEEm8Vm79dQI6Lh98tuKSkpIXfSyJFiZY/94p2IwmBSQAEJ1kbEy2LwciU1NcmTdNFFIhzFxRhE29sIw5IlsmRg1CjHwRjCgMJCzMWDePQea+YfwZUEwLvu9oYNdrGbaDhSVtPTxQ2yfDlQu7fRTlU1DBoE+P3ouWN9KOkrosVQVCR/k7VrZeTzysgbNw74+GMMKJZZ+YUBh4ilpqJ36om4KqyebE5Dj/QowpCfDxw+jFEjWlFVJZPlU6escuAFh+y4lmH1aiAnB6XYgbpjaTh+XC5XS2uKZMlVVKAQe7Bnfwr27pXPc7qSsrPlK8NLjGzd3IzC1APIXPFm6JhZy1BbCxw+xLgQn8MX7Gu/qbzcnW1orqmlOtHWMsyfL+344Q8l4/Sxx4CpF++SVNhjx+TGhNTBnDJFzvnb34Ah2fvk2Yroaz27qDAkG7Nny3Ln8ePl9YQJcrNVVcmNF+7mMMIQZjEET++UHz/faBclysmROgFWALpPH6B6zXFcfHSV9w0dCIQshosu8q65FCJeV1JNjYiDWbA1fDgGnVyP/fvtcfzLL8V3PW1amOsqUjkMQ0EB7sKzuKy/9dRHE4Zwi8HsBhRPXS5HyiogltTGjcCnG1PaCkNqqswiq6tlv2pAYgxewkAkzvRly+S1lzBUVgJNTbhmcA0mZryL7L7udNPePRpx9JTMnpuaIi8cO9GSgaz0KLGI/v0BZowe8AU+/1yyiT79VD6zYsVcsWTNSi+T7TZ9OkqwE4DECsyqZ6fFcOKUPxRfd85lAIRKmTvZuqERg5qqJahhdcS5yK32YLP8zcN3o3ISVvGwpMQ7xnDwoGz0861vycrpefOAx3/YhNTZ3xBLu7g4VD3A5xOPb3Gx3N7ltEU+uIsqKagwJBtPPmk7LwERgzvukJ979Wrr5PeyGByL3Prt/8gWBkDiDB98YO8YY4riR7AY0nEa/XudaFOQrA1m8I/lSjKBZxNNHD4cY49I+tGjj8qhFStkQu+KLwCOGuEeC9wA10Y6ANonDHv3ivDEk15oprqOADQA7DyQ0VYYAFdmEhDFlQRInMG0P5LFAGB62p/xju9rocqqht7ZzTjWlIVduySb6/LLZaBrdqx5a2oCmjgVPTKi7MJj9WF0P1lPUVVl+/8rdr8qfTfpWJs3i4UzYQJKesl9sGMHHLW6vgDKylAI6dfq1XLcaTEAMtHfssWdmVSz04/B2CrW3BtvAAgThv3Nsuo52qxlwAARaEdmUl2dHVIy/PGPoj033eQ4+IMfyPPy3HPAjBnSeMva7N1b9lwYNAiY0Ph2l7mRABUGBZDavX5/WzcSYB9zWgzBICbi/zB59BGUNqx3C8MVV0i+4YoV8jqaMFhP4Ed3zcfjj8doo4kxxHIlbdxoZ4oAwPDhmNTyNubMrsMvfiFp50uWiGHkSlMFYruSzkQYzKgXj8UQDMr1sCyGkSNluwQA3sIwbBiwbRtGDBPXTURXEuBeVu4lDMGgjKirVkkfwkSy1wUyqo4YIYuoZ8+WtRo33mjvDRCKyWdGsRisPlycWYOUFIkzrFsnGzoVY6dcQ7NPphnpx49Hab4EtHfudAhDXguQno6CXMmUM7v1upLgtm5F+aFVqK+31yYcPQrUHU8XYQgGxX/D7KqXVHuYY1sMfr9Er8PWMoS7kxYuFF0OlV957z1ZAXn33VINedIkCWyY/kLO3foZ4x8PLETbbIbOQ4VBkZv+1lvDlgBbRHAljUEVlk15SnZUcwrD5Mny0JvC/9GEwVpm2rdhe2wLObRhRI59zLi9nK6kjRvlu0wQ2LIcnrhmBa6/HpgzR0z0KVM8JtV1dfKQR8oa6tdPLKyOCINx1ZlpfTR8PhEhSxh8PlkRDgB5vqO2ShiGDQNaW3FJD8nJTcfpthlgBpOZBLh3mXEybpxdEDFMJPNyZbAvLpaB/KWXJMHt1VdlN7MnnpDxFYi+JboRpawjssK7qsoKPOftBqWkSEL/n/4ko/Pq1ZJDOnAg8oqzkElfYudOhyspKFauEYJ16xzVaMw+r+XlGLL4xwDsOIOJOw3K2CdR7jVrgBUr3BbDUZ8IQ1Q/J+CseGgeFacw7NolTXFZC6+/LpaG2Q/08sslMu0oRglAOnrihFoMSjfw7LMypQmnf38Rh76O4JsZUMzMxikM6elS3GvVKllqun27vN/LGgHkgQvfS9GL+noZaZwZPT6fDMROi2HDBju+AIjlkJIC36ZP8fLLon0NDWHZSAazuC1SzqzfL301s38z+DtHwEhZSVVVMnhEHS0dONYyAPbCv7zezW3bZ/m4S+o/QWHPoyjwH4zcB+NiS0trKzCGcePs9ocJwz9V7MKL/tvwwfscmsDee6/kLvz1r3Lp584FeqABw4NRKuT16SPXcv9+jBolq483bAAqWteIeN13n/inXnxR7rPx4wEiUEE+SlJ2hyyGnikN6BGUyUJwYBZSIFlJRUUQq/Wyy0INK4cEGEycIZSqWnhK/GHBIPCTnyA7Wy7TgQNA3fG02BYDIPfZtm3A6dOe+zKYR+vGGx3vWblSYjpmwWNWlrTXuNAMZrGFCoPS5UQaSB56SJ5a5++NSKxZI8ed1gQgMYu8PFmyvz1CqqohELB9AgZmYPFiGSAuvVS+P7yyqsFZL8lUD3UKQ0aGmPkbNiArS7IC582TfSjaEGnVs5OpUyVF6Pjx9mUlxRt4Nlirnw3XXAP09h/DiPwjbc8tKwNSUkDVm7Dx5v/AA9kRajcDItAFBfbObV5YC90AtHElZfTrhW82L0Bmq1v4vv1tuUTHjkmMoSG9D8YPCruuTqxyHnjvPYweLRlALS1AxcGlUvF4yBCZQf/85zL1NskSBQUobanBju2tsq0sHQoN2v6SAgSt2FdxMcSpn50tI/TPfobCQBMyfY0hYQilqpb5ZUJz//0yWL//PgIBU9mWpBxGpLiTYehQ6UBNDfr0kdvAaTEsXCh6G3oU6utlsmBMQcPEiZKR5dxfVIVBOefIyWl7Q6any2zz1CmZmoX7ZLKyZFXSsmUy2wsvnuekXz+3MFRVyYAwY4ZE6nbvloFq8eK2u/eY9hlX0mefySzTKQyAzJKtSnR9+8rzH3LBm00lgPiE4frrRYDefluEISXF3X8vV9KBA9LH9tS1KSoSl5UV1S0qAuqKRqNyqEc1wMxMGXGqq9GztR7+jAhuJMOVV0rgIhKjR9uuqPC/R16e/O9ReKhHD/HC+alFAg5elVWdfP3rwLvvYnS+bTFWfLnKLoV/xx22v8gIQ36+LHLbwTh4gBFs2WvP5ouKUABJoy4qZKl5ctVVIddgSvlgDE7fE3Ilbd3KKKQ9yBxkxWzuvFP+lq+8gkDALl6Yl9MY2TVncGQmEblTVjdvlrHe5UZatUru73BhMIvmTIwOkPs6I8OOcXUBKgxKxzDuJKcbycl3vysz/IaG6BaD05V0/Lg8yNu2SeDxk0/kqXrgAfkcr2Cps/R2eEaSYfhwmR6Gz+J/9zt52J54Ql7HIwxf+YrMHl9/3a6s6px5Z2TIa6cwmKW97bUYWlrsgZEZtH9f28CzYdgwKV3SGCXwbHj+eRHaSGRm2rGQ8L/HddfJIHjDDcBrr3m/32tFuBfWSDmyWgpNBnJOIh/7bGGYMUPuoawsW8gsYTha78OWza2SHWcs2KIiWR0MoDjjkLjinLs+lZdjSMsG22KobsZg/syOFmdny8KWdesQCNgFaPvmRsmucnw2gFAAo6RElovccIOsGfT5rNLrhhUrZELhtM4AuUd693bHGbZsEau3C+uuqTAoHcME4yIJQ06OrO0HYruSjh2TxQW/+pX4I5YskeCjCQTPnSsuohdeaPt+40o6dMjeaCI8e+OrXxX31COP2Mf27RPx8vvl+Jo18QmDzyd5rm++KW0NH/yIQvsrh/jwQzkebZYeTljKKr74Qiy0SGXihw6VmWVDQ2xhiKe4oxmwwv8eubliLYwaJQO3yRxy4hV78WLgQKCyEhe8+gKGDAEqL6gGBQL2QJ2ZKQn/c+bYsaX8fJRCpuIHD/tEGFwWgyQGFB2wNllwCkNZGcob12PHDkZjI7C1BhiEGvditbFjgY8+Qt8+dkZVXiCOKsw9esg1swLQF18sml5VJfWyVq4Mu3QrV4oAhl8rn0/WFr3zjp1X+9lnXepGArpYGIhoChFtIaIaInrY4/f3EdEmIlpPRMuJqNjrc5RzgFjCAIg76eabJQUo1ufs2QM89ZTkkI4d2/a8khJvUzonR+IYY8fKCqnf/rbtwzZhggwuTz8NLFggD9xtt4lL6L335Im96SZZZxBLGABxJ9XXi6vMa1YcLgxVVfJgx6qR5CRskVvIrxG+asswbJg49zdtOjuLoB580K7wFk5urgRIr75a3C+mLrjB1LiIlPXk5OabgfXrsfTJz/C/vu/JYOm0wO65R2JVBstiMES0GDb9Wf4mzsUMZWUoxxa0thLWrQPq6lMlVdUpDBUVwMmTCPjsWE5efpx/T0dZ88cek9ty506p0H355Y7z6urEGg53IxkmTpTn4aGHJMayfXuXCwOYuUv+AfAB2AZgAIA0AJ8AGBZ2zpUAsqyf7wbwSqzPHTNmDCvdwP33MwPMr712Zp/z5pvyOXffLf+/9Vb73n/rrfK+ggLmDz+MfF5TE/OkScypqcx33SXv+eUv5XerVzP7fHJs7tzY33nyJHNWlpx/ySVtf19ayjxrlv26sJD5ppva16+GBvn8n/5UXt9yC3N2NvOxY97nr10r5xMxjxvXvu/qKF9+yRwIME+e7D4+aRJz//7MjY2xP+PgQfnb33abtH/evOjnt7ZybUYBi7ozP49bmDdtCv1uc/olPHPQB3wqNZv5+993v3fzZl6LMQwwP/KIdftiOvPWe4ZOAAALHElEQVTx465zGOD/mvl+6DtOz3kgdj+YmZ96St6wfHn08xYvlvPefdf793v2MAeDHGoAwLxoUXxtaAcA1nGEcbUrLYZ/AFDDzNuZ+TSAhQBcSYPMvJKZjSP4AwBdF21R2kc8FkM8GDfA/PkSC4hmXXhx9dXi2lm7NroP3++X1JCiIpnCTZ4M3HWX/O6yyxBaYWeCq9HIzLTbGctiqK2V2V974gvmM3JzxZV09KiU4Zw5M7LVYRb0MXdZ2QRkZEiu6l/+Ytc2+vRTcYPcc4+kxMYiEJAZ8oIF8jrWHuxEyM3PQLbfKvvudCURobykEb89MgXpTQ1uNxIAlJaiPEVSkcz2mYN7HXHvjzF4MJCTg0CtzPx743Ok9o/jngDkfioslPIa0fZiXrlS3GzOTSCcFBRIgKO5WYop7tsnazG6kK4UhnzAsvOEvdaxSNwG4M+d2iKl49xwgwwK8RSFi4YRmJYWcV+0d1e9G2+UhVCxFiABkkn1xhsywC5Y4P6uhx+WJbzxPoBmS8VYwmACzx3ZacukrP7mNxJf+M53Ip+bnW27Tbpqn3FAVu2aOBAg7sCsrKh7j7dh5kwZSNPS4hJQKshHSZpEhvv5jrjTmIuK7NiPyWQypKWh58C+6J/xeaie0oCBYfdbSgowZgwCu2VjiJjlMJxkZMgEY+1aWfEXiZUrZTISSzh9PglER0st7iS6Uhi8euYpq0Q0C0AFgHkRfn8nEa0jonW1XruJK53PgAHi/4yVxhcL4x8uLJRtujqboUMlDhGe3ePzAbNmuVdWR+Paa+U9XgHWHj0kPXXpUlmgBYSVcY0Ts8jt2WclhhLrM0ytha4Uhl69RLBeeQV4/33g5ZdlsVikxXNeXH+9tHnMmPjanp+PEt4JAAj2aXIH0o04XnWVt+VUVoZyn1gNhf79yBzoEcyvqEBgm9TViGtxm5PZs+Uee/RRmfG3tsp6ivvuk/+rqyV7LlJ84RyhK4VhLwBn9ZICAPvDTyKiiQAeBTCNmT23gGLm+cxcwcwVefGY/sq5S2qqPEzz5sXep+Bc4sILxcrwsjByc6WQ0HXXyU7vY8d6L86LRXGxDCKbNkW3Fgwml76rXEmGOXNEJKdOlQD4vfe27/09e0p2049+FN/5BQUobdwMPzWjTzDsnjHCEO5GMpSXY8gpcXsNbtncdnEmAIwdi0CTODfaLQx+v9QE2bJF/g6jR8t6jaeflv+NeJ/jwnCG0712sRbAYCIqBbAPwDcA3Ow8gYhGAXgWwBRmPtz2I5SE5KWXursFHePHP/Y+/uST4h4JBu1/HcEMcjk58VlT3WExAGJ9zZ4t7rlp0zqWQTNrVru+777Webgybz18gbAVySNGSP+vvdb7vWVlKG+R9S6DOCwjyVBRgQtQjzQ6jTyuBfpdFn/bAKm3UlkpGzcPHCgW6owZ4lZcvlziBl6Zd+cQXSYMzNxMRN8DsAySobSAmTcS0Y8g0fElENdRNoA/kvjUdjNzeHFkRTm3KSg4O6tUjTDMmhV7sRhgC0NXWwyApFauWCFlpDub/HyUYBdKaucDgW+6fzdtmrjxvFbJA1bKqizMk1TVSW3PKSkB5eZift0dGE0fA31ub1/7iMRSXLtW3GTGEr70UnuP0XOcrrQYwMxvAXgr7Nhjjp8ndmV7FOWcprJSXBHxumaMK6mrLQZArIRoGx2fTZzxIWdxR0AG5UiiAADl5ajAOpRl7MKVp1YCpR5BciKgogK3LHsJyOsrbrL2UlLi7aY6T+hSYVAUpR0UFLTdvT4avXtLdcDwbJxEwykM7fH/A0AwiD7ZjdhyolTSYSItGBw7VhYwxpuRlGCoMChKIrFoUXe3oPPp109m9cztFwYisW6qqkRgIrndzN4k7f38BEFrJSmKcn6RmmoP2OGupHgwwXGvwLPBBIdVGBRFUc4TjDupIwO3KbIYTRj695eUUleRo+RBXUmKopx/5OdL/KUjwhCPxQC490RIMtRiUBTl/MOkA8faWc0Lk70VbQOpJEctBkVRzj9uv10G9o6slh85UtYZmHpXShtUGBRFOf8YNapj9acAyUzqirpc5zHqSlIURVFcqDAoiqIoLlQYFEVRFBcqDIqiKIoLFQZFURTFhQqDoiiK4kKFQVEURXGhwqAoiqK4IGbu7jacEURUC2BXB9/eB8CRs9ic84Vk7Hcy9hlIzn4nY5+B9ve7mJnzvH5x3gvDmUBE65i5orvb0dUkY7+Tsc9AcvY7GfsMnN1+qytJURRFcaHCoCiKorhIdmGY390N6CaSsd/J2GcgOfudjH0GzmK/kzrGoCiKorQl2S0GRVEUJQwVBkVRFMVF0goDEU0hoi1EVENED3d3ezoDIiokopVEVE1EG4noXuv4hUT0DhFttf7v3d1t7QyIyEdEHxHRUut1KRH93er3K0SU1t1tPJsQUS8iWkREm61rfmkyXGsi+jfr/t5ARL8nooxEvNZEtICIDhPRBscxz+tLwtPW+LaeiEa357uSUhiIyAfgfwB8DcAwADcR0bDubVWn0Azg+8w8FEAlgO9a/XwYwHJmHgxgufU6EbkXQLXj9c8APGX1+yiA27qlVZ3HLwC8zcxDAIyA9D2hrzUR5QP4VwAVzDwcgA/AN5CY1/oFAFPCjkW6vl8DMNj6dyeAZ9rzRUkpDAD+AUANM29n5tMAFgKY3s1tOusw8wFmrrJ+Pg4ZKPIhfX3ROu1FAAm3+S0RFQC4FsBz1msCMAHAIuuUhOo3EeUA+CqAXwMAM59m5i+QBNcaskVxJhH5AWQBOIAEvNbMvArA52GHI13f6QBeYuEDAL2IKBjvdyWrMOQD2ON4vdc6lrAQUQmAUQD+DiDAzAcAEQ8AfbuvZZ3GzwE8CKDVep0L4AtmbrZeJ9o1HwCgFsDzlvvsOSLqgQS/1sy8D8ATAHZDBKEewIdI7GvtJNL1PaMxLlmFgTyOJWzeLhFlA1gMYA4zH+vu9nQ2RDQVwGFm/tB52OPURLrmfgCjATzDzKMAnECCuY28sHzq0wGUAugPoAfEjRJOIl3reDij+z1ZhWEvgELH6wIA+7upLZ0KEaVCROFlZn7VOnzImJXW/4e7q32dxGUAphHRToibcALEguhluRuAxLvmewHsZea/W68XQYQi0a/1RAA7mLmWmZsAvArgK0jsa+0k0vU9ozEuWYVhLYDBVuZCGiRYtaSb23TWsfzqvwZQzcxPOn61BMAt1s+3APhTV7etM2HmR5i5gJlLINd2BTPPBLASwAzrtITqNzMfBLCHiMqtQ1cB2IQEv9YQF1IlEWVZ97vpd8Je6zAiXd8lAL5pZSdVAqg3Lqd4SNqVz0R0DWQW6QOwgJl/0s1NOusQ0XgA7wL4FLav/QeQOMMfABRBHqx/ZubwoFZCQERXALifmacS0QCIBXEhgI8AzGLmxu5s39mEiEZCgu1pALYDuBUy+Uvoa01EjwO4EZKF9xGA2yH+9IS61kT0ewBXQMprHwLw7wBeh8f1tUTyvyFZTCcB3MrM6+L+rmQVBkVRFMWbZHUlKYqiKBFQYVAURVFcqDAoiqIoLlQYFEVRFBcqDIqiKIoLFQZF6QSsSqf/0t3tUJSOoMKgKJ1DLwAqDMp5iQqDonQO/wlgIBF9TETzursxitIedIGbonQCVjXbpdYeAYpyXqEWg6IoiuJChUFRFEVxocKgKJ3DcQA9u7sRitIRVBgUpRNg5joAf7M2qNfgs3JeocFnRVEUxYVaDIqiKIoLFQZFURTFhQqDoiiK4kKFQVEURXGhwqAoiqK4UGFQFEVRXKgwKIqiKC7+H5Mhx/ClS90IAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(inf_norm_train_NN, color='red', label='NN')\n",
    "plt.plot(inf_norm_linear_in, color='blue', label='OLS')\n",
    "plt.ylabel('$L_{\\infty}$-norm (in-sample)')\n",
    "plt.xlabel('t')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(inf_norm_test_NN, color='red', label='NN')\n",
    "plt.plot(inf_norm_linear_out, color='blue', label='OLS')\n",
    "plt.ylabel('$L_\\infty$-norm (out-of-sample)')\n",
    "plt.xlabel('t')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sensitivities\n",
    "Plot the sensitivies of the neural network to the input factors and compare with OLS regression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2.9119727e-09,  1.6448817e-08, -3.6024763e-09,  1.4996275e-09,\n",
       "        9.7157580e-09, -2.9344158e-09], dtype=float32)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "betas['NN'][i][0][1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "n_var = np.shape(betas['NN'][1])[1] - 1\n",
    "\n",
    "mu = np.array([0]*training_periods*n_var, dtype='float32').reshape(training_periods, n_var)\n",
    "sd = np.array([0]*training_periods*n_var, dtype='float32').reshape(training_periods, n_var)\n",
    "mu_ols = np.array([0]*training_periods*n_var, dtype='float32').reshape(training_periods, n_var)\n",
    "\n",
    "for i in range(training_periods):\n",
    "    mu[i, :] = np.median(betas['NN'][i], axis=0)[1:]\n",
    "    sd[i, :] = np.std(betas['NN'][i], axis=0) [1:]\n",
    "    mu_ols[i, :] = betas['linear'][i][1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['EV', 'P/B', 'EV/T12M EBITDA', 'P/S' , 'P/E','Log CAP']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(2, 1, figsize=(20, 10))\n",
    "fig.subplots_adjust(hspace=.5)\n",
    "fig.subplots_adjust(wspace=.7)\n",
    "%sc = 10000\n",
    "idx=np.argsort(np.median(mu[:, 0:n_var], axis=0))\n",
    "axes[0].boxplot(mu[:, idx])       # make your boxplot\n",
    "axes[0].set_xticklabels(np.array(names)[idx], rotation=45)  \n",
    "axes[0].set_ylim([-0.1, 0.1])\n",
    "axes[0].set_ylabel('Sensitivity (NN)')\n",
    "axes[0].set_xlabel('Factor')\n",
    "idx = np.argsort(np.median(mu_ols[:, 0:n_var], axis=0))\n",
    "axes[1].boxplot(mu_ols[:, idx]) \n",
    "axes[1].set_ylim([-0.1, 0.1])\n",
    "axes[1].set_xticklabels(np.array(names)[idx], rotation=45) \n",
    "\n",
    "axes[1].set_ylabel('Sensitivity (OLS)')\n",
    "axes[1].set_xlabel('Factor');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above sensitivities are sorted in ascending order from left to right. We observe that the OLS regression is much more sensitive to the factors than the NN."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
